home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / utilities / heartbeat.lha / HeartBeat / hb.c < prev    next >
C/C++ Source or Header  |  1994-05-29  |  76KB  |  2,363 lines
  1.  
  2. /*****************************************************************************
  3. * HeartBeat 1.0                                        (C) L. Vanhelsuwé 1992-94
  4. * -------------                                        -------------------------
  5. *
  6. * Written by Laurence Vanhelsuwé in April 1992
  7. *
  8. * HeartBeat is a generic Amiga system call monitor.
  9. * It allows you to monitor a Task's system calls usage or monitor global
  10. * system call activity.
  11. * This program uses the standard Commodore .FD files for all its information
  12. * on available libraries and system calls. This results in a program which
  13. * isn't locked to a certain revision of the Operating System but one that
  14. * evolves with it.
  15. * Additionally, executable size is kept small by not having system call info
  16. * embedded inside the program.
  17. *
  18. * History
  19. * -------
  20. * 06-APR-92: started coding        (goal: loading and parsing of all .fd files)
  21. * 07-APR-92: had a look at gadtools stuff (done most of register requester)
  22. * 08-APR-92:                    (goal: function selection/constant refresh)
  23. * 10-APR-92: modified event loop to more robust global event port system
  24. * 16-APR-92: added new/load/save project options
  25. * 22-APR-92: discovered ASL FileRequest doesn't return full filename! Arghh
  26. * 26-APR-92: added non-ROM vector highlighting (handy for VIRUS detection !)
  27. * 13-JUN-92: added function address printing
  28. * 22-APR-94: Finally cleaned up ASL Filerequester code!
  29. * 
  30. * To Dos:
  31. * -------
  32. * - **!! Ensure monitored libraries don't ever get flushed while we run.
  33. * - Fix currentdir change side-effect
  34. * -
  35. * -
  36. *****************************************************************************/
  37.  
  38. // **!! REQUIRES 2.0 OS !!    (CHECKED AT RUN-TIME)
  39.  
  40.         // Include Amiga specific header files
  41. #include    <exec/execbase.h>
  42. #include    <exec/io.h>
  43. #include    <exec/memory.h>
  44. #include    <exec/nodes.h>
  45. #include    <exec/types.h>
  46.  
  47. #include    <devices/timer.h>
  48.  
  49. #include    <dos/dosextens.h>
  50.  
  51. #include    <intuition/intuition.h>
  52. #include    <intuition/intuitionbase.h>
  53. #include    <intuition/gadgetclass.h>
  54.  
  55. #include    <libraries/asl.h>
  56. #include    <libraries/gadtools.h>
  57.  
  58. #include    <utility/tagitem.h>
  59.  
  60.  
  61.         // Include standard C headers and Lattice specific headers
  62. #include    <stdio.h>
  63. #include    <stdlib.h>
  64. #include    <string.h>
  65. #include    <ctype.h>
  66.  
  67.  
  68.         // Include function prototype definitions
  69.         // Headers coming out of the PROTO directory include #pragmas to use
  70.         // registerized system call calling.
  71.  
  72. #include    <clib/exec_protos.h>
  73. #include    <clib/graphics_protos.h>
  74. #include    <clib/dos_protos.h>
  75. #include    <clib/intuition_protos.h>
  76. #include    <clib/utility_protos.h>
  77. #include    <clib/gadtools_protos.h>
  78. #include    <clib/asl_protos.h>
  79.  
  80. void NewList( struct List *);
  81.  
  82.         // Include Application private headers
  83. #include    "cload_file.h"
  84.  
  85. // All system functions which are currently being tracked have a context
  86. // structure associated with them so that patch stubs can use this to store
  87. // function-specific (local, contextual) information.
  88.  
  89. struct Context {
  90.     ULONG    regvals[16];        // D0..D7, A0..A7
  91.     ULONG    regmasks[16];        // don't care bits for above
  92.     USHORT    freeze;                // freeze on match or just count ?
  93.     USHORT    frozen;                // wedge froze Task TRUE/FALSE
  94.     ULONG    called_cnt;            // each time func gets called this increments
  95.     ULONG    trapped_cnt;        // each time input registers match template
  96.     ULONG    last_called_cnt;    // last value of above (to optimize update)
  97.     ULONG    last_trapped_cnt;    // last value of above (to optimize update)
  98.     APTR    stdvector;            // ptr to normal ROM/RAM routine for this syscall
  99. };
  100.  
  101. // Every library function found in the .fd files gets a structure as follows:
  102.  
  103. struct SysCall {
  104.     struct    Node func_node;        // a node so we can link ya all together
  105.     char    *funcname;            // ptr to name of system call (eg "CurrentDir")
  106.     USHORT    namelen;            // length in bytes of name
  107.     SHORT    func_LVO;            // the _LVO for this function    (eg -$C0)
  108.     struct    Library *parent_lib;// this func belongs to library X
  109.     struct  Context    *ctxt;        // ptr to context struct for patch.
  110. };
  111.  
  112. //-------------------------------------------------------------------------
  113.  
  114. #define        MAX_LIBS        40        // can't cope with more libraries !
  115. #define        MAX_FUNCS        1500    // can't cope with more functions (total)
  116. #define        MAX_PATCHED        72        // can't cope with more PATCHED functions
  117. #define        MAX_FILENAME     512        // maximum absolute filename (LONG PATHS on networks!)
  118.  
  119. #define        POOL_SIZE    (MAX_FUNCS*sizeof(struct SysCall))
  120.  
  121. #define        LF            10
  122.  
  123. #define        REFRESH_FREQ    4    // times a second update call counters
  124.  
  125. // Enumeration type for app_state (application state)
  126.  
  127. #define        FUNCWINDOW    1        // window with function list active
  128. #define        MONWINDOW    2        // window with tracked functions active
  129. #define        REGSWINDOW    3        // register set requester window active
  130. #define        TASKWINDOW    4        // task requester window active
  131.  
  132. #define        WINWIDTH    640        // Need interlace Workbench to open !
  133. #define        WINHEIGHT    340
  134. #define        PANE_X        5        // offset to Gimme00 area.
  135. #define        PANE_Y        12
  136.  
  137. #define        MAX_LABLEN    20        // extra long function names are chopped
  138. #define        MAX_TASKLAB    20        // maximum length of a Task name string in req.
  139.  
  140. #define        CHAR_WIDTH    8        // pixel dimensions for Topaz 80
  141. #define        CHAR_HEIGHT    8
  142.  
  143. // Enumeration type for our scan_state variable
  144.  
  145. #define        NEED_NAME        0    // initial state to grab head like * "dos.library"
  146. #define        NEUTRAL            1    // neutral state to find out what we're looking at.
  147. #define        GET_FUNC        2    // get all other lines
  148. #define        GET_COMMAND        3    // get line with ##cmd
  149.  
  150. #define        ERR_OK            0    // no error occurred
  151. #define        ERR_BADFILE        1    // incorrect file format
  152. #define        ERR_DOSERR        2    // failed to save file
  153. #define        ERR_NOMEM        3    // running out of memory...
  154.  
  155. #define        HB_SIGNATURE    ">>HeartBeat Session dump (C) LVA 1992\n"
  156. //-------------------------------------------------------------------------
  157.  
  158. // Function Prototypes
  159. // -------------------
  160.  
  161. struct    MsgPort *CreateMsgPort    (void);
  162. void    DeleteMsgPort            (struct MsgPort*);
  163.  
  164. // Local function prototypes
  165. //--------------------------
  166.  
  167. void    cleanup                    (void);
  168. void    exit                    (int code);
  169. void    text_to_heap            (struct FileCache *fc);
  170. void    refresh_counters        (void);
  171. void    handle_quit                (void);
  172. void    handle_activation        (void);
  173. void    handle_menuselection    (SHORT menu);
  174. void    handle_keypress            (char key);
  175. void    handle_click            (void);
  176. void    handle_gadgets            (void);
  177. void    append_lib_menus        (void);
  178. void    display_functions        (void);
  179. void    handle_mousemove        (void);
  180. void    unpatch_functions        (void);
  181. void    find_function_info        (void);
  182. void    popup_About_req            (void);
  183. void    reset_counters            (void);
  184. void    kill_taskReq_window        (void);
  185. void    kill_regsReq_window        (void);
  186. void    watch_task                (int index);
  187. void    quick_msg                (char *message, char *exit);
  188. void    strip_lf                (char *str);
  189. void    collect_taskinfo        (struct Node *task);
  190. void    CloseWindowSafely        (struct Window *win);
  191. void    StripIntuiMessages        (struct MsgPort *mp, struct Window *win);
  192. void    init_context            (struct Context *cx);
  193.  
  194. void    fill_box                (int x, int y, int yoffs, int width, struct RastPort*, int pen);
  195. #define    highlight_box(x,y,w)    fill_box(x,y,0,w,rp,3)
  196. #define    erase_box(x,y,w)        fill_box(x,y,0,w,rp,0)
  197. #define    highlight_monbox(x,y,w)    fill_box(x,y,12,w,monrp,3)
  198. #define    erase_monbox(x,y,w)        fill_box(x,y,12,w,monrp,0)
  199.  
  200. BOOL    init_program            (void);
  201. BOOL    process_fd_file            (struct FileCache *fc);
  202. BOOL    popup_funcwindow        (void);
  203. BOOL    add_function            (struct SysCall*);
  204. BOOL    ask_register_info        (char *wintitle, struct Context *ctxt);
  205. BOOL    ask_task                (char *wintitle);
  206.  
  207. int        calc_num_fd_files        (void);
  208. int        load_funclist            (void);
  209. int        save_funclist            (void);
  210.  
  211. char    *get_filename            (char * windowmsg);
  212.  
  213. struct SysCall *find_func        (char *libname, char *funcname);
  214.  
  215. //-------------------------------------------------------------------------
  216. // Global variables
  217. //-----------------
  218. extern struct ExecBase        *SysBase;
  219. extern struct IntuitionBase    *IntuitionBase;
  220.        struct GadToolsBase     *GadToolsBase;    // not part of lc.lib this one
  221.        struct AslBase        *AslBase;
  222. extern struct GfxBase        *GfxBase;
  223.  
  224. extern void WEDGE(void);            // to be copied and patched
  225.  
  226. struct library {
  227.     struct List        funcslist;        // functions for this lib/dev/resource
  228.     char            *libname;        // name of this library/device/resource
  229.     struct Library    *openhandle;    // ret from OpenLibrary/OpenDevice/OpenResource
  230.     int                numfuncs;        // # of entry points
  231. };
  232.  
  233. struct library libs[MAX_LIBS];        // an array to store info on all libs
  234. struct library *curlib=NULL;        // curlib points to the current library
  235.  
  236. struct SysCall *patched_calls[MAX_PATCHED];    // array of ptrs into patched funcs
  237. struct SysCall *selected_syscall;    // -> selected func for register template
  238.  
  239. struct SysCall *node_pool,*pool_base;
  240. struct Context *ctxt_pool;
  241.  
  242. struct Task *SNOOP_TASK;            // Task that's being monitored
  243. struct List taskList;                // global list header for LISTVIEW gadget
  244.  
  245. struct MsgPort *timerport,*IDCMPport;        // our two main IPC ports
  246. struct timerequest timereq;
  247.  
  248. struct Window    *window, *monwindow, *taskwindow, *regswindow;
  249. struct Screen    *screen;
  250. struct RastPort *rp,*monrp,*regsrp;
  251. struct Menu        *menustrip;
  252. struct TextAttr *TAttr;
  253. struct Gadget    *taskReqGads;        // ptr to gadlist for Task Requester window
  254. struct Gadget    *regsReqGads;        // ptr to gadlist for Regs Requester window
  255. void   *vi;                            // global VisualInfo ptr for Workbench Screen
  256.  
  257. struct FileCache fd_caches[MAX_LIBS];    // bookkeeping for cached .fd files
  258. struct FileCache FdDirCache;            // for .fd directory listing file
  259.  
  260. int num_fdfiles;                    // number of .fd libraries        (Constant)
  261. int numlibs;                        // number of accessible libs    (Constant)
  262. int total_funcs;                    // total numer that we know of
  263. int libnum;                            // index into library array (Variable)
  264. int lowlibs;                        // # of libraries in A..I menu
  265. int monitored;                        // # of functions monitored (= patched)
  266. int app_state;                        // state application finds itself in...
  267.  
  268. char filename_buf[MAX_FILENAME];    // large buff to construct abs file names
  269.  
  270. struct RDAres {                        // array for ReadArgs()
  271.     ULONG forceopen;                // force Library to be resident
  272.     ULONG verbose;                    // print lots of debug info.
  273. } options;
  274.  
  275. #define    VERBOSE        options.verbose
  276. #define    FORCEOPEN    options.forceopen
  277.  
  278. SHORT winwidth=WINWIDTH, winheight=WINHEIGHT;
  279. SHORT maxrows;                        // # of rows to print functions
  280. SHORT mousex,mousey;
  281. SHORT msgcode;
  282. SHORT oldboxx = -1, oldboxy = -1;
  283. SHORT oldmonboxy = -1;
  284. SHORT task_num;                        // "remember" variable for Task Req gadget
  285.  
  286. APTR IAddr;                            // ptr to Intuition object (Gadget,..)
  287.  
  288. BOOL quit_me;                        // IDCMP quit request
  289. BOOL menus_exist = FALSE;            // SetMenuStrip() not yet...
  290.  
  291. //-------------------------------------------------------------------------
  292. // A NewWindow struct to open application Windows (re-used many times)
  293. // (Initial values are for main function window only)
  294. //-------------------------------------------------------------------------
  295.  
  296. struct NewWindow nw = {
  297.     0, 16, WINWIDTH, WINHEIGHT,
  298.     255, 255,                        /* Default pens */
  299.  
  300.             // I want to know about following IDCMP Message types
  301. //    IDCMP_CLOSEWINDOW|
  302. //    IDCMP_ACTIVEWINDOW|
  303. //    IDCMP_MENUPICK|
  304. //    IDCMP_MOUSEMOVE|
  305. //    IDCMP_MOUSEBUTTONS|
  306. //    IDCMP_GADGETUP|
  307. //    LISTVIEWIDCMP|
  308.  
  309. // All windows we open get this set of IDCMP bits attached to them.
  310. // Not all windows can generate all those types of msgs though, but that
  311. // doesn't matter (Jimmy).
  312.  
  313. #define    IDCMP_SELECTION (IDCMP_CLOSEWINDOW|\
  314.                          IDCMP_MENUPICK|\
  315.                          IDCMP_MOUSEMOVE|\
  316.                          IDCMP_MOUSEBUTTONS|\
  317.                          IDCMP_GADGETUP|\
  318.                          LISTVIEWIDCMP|\
  319.                          IDCMP_ACTIVEWINDOW)
  320.  
  321.             // BUT we force Intuition to use our own MsgPort so specify 0 here
  322.     0,
  323.  
  324.             // Standard window flags
  325.     WFLG_ACTIVATE|
  326.     WFLG_CLOSEGADGET|
  327.     WFLG_DEPTHGADGET|
  328.     WFLG_DRAGBAR|
  329.     WFLG_REPORTMOUSE,
  330.  
  331.     NULL,                // No gadgets in this window
  332.     (struct Image *) NULL,
  333.     "Amiga HeartBeat 1.0 (written by LVA © April 1992)", // Window title
  334.     (struct Screen *) NULL,
  335.     (struct BitMap *) NULL,
  336.     100, 40,                /* Minimum sizes */
  337.     65535, 65535,            /* Maximum sizes */
  338.     WBENCHSCREEN            /* and put it on the workbench */
  339. };
  340.  
  341. //-------------------------------------------------------------------------
  342. // Menu Layout in compact GadTools format.
  343. //-------------------------------------------------------------------------
  344.  
  345. #define    PROJECT_MENU    0
  346. #define    OPTIONS_MENU    1
  347. #define    LIBS_1_MENU        2
  348. #define    LIBS_2_MENU        3
  349.  
  350. #define     NEW_ITEM         0
  351. #define     LOAD_ITEM         1
  352. #define     SAVE_ITEM         2
  353. #define    DUMMY_ITEM0         3
  354. #define     ABOUT_ITEM         4
  355. #define     QUIT_ITEM         5
  356.  
  357. #define     RESET_ITEM         0
  358. #define     GLOBAL_ITEM     1
  359. #define     TASK_ITEM         2
  360.  
  361. // First empty slot @ offset N
  362. #define    NEWMENU_APPEND    12
  363.  
  364. struct NewMenu mymenus[MAX_LIBS+NEWMENU_APPEND+2]= {
  365.     { NM_TITLE,        "Project",    NULL,    0,0,0},
  366.     { NM_ITEM,        "New",        "N",    0,0,0},    // Kill monitor window
  367.     { NM_ITEM,        "Load Session...",    "L",    0,0,0},    // Load monitor window selection
  368.     { NM_ITEM,        "Save Session...",    "S",    0,0,0},    // Save monitor window selection
  369.     { NM_ITEM,         NM_BARLABEL,NULL,    0,0,0},
  370.     { NM_ITEM,        "About...",    NULL,    0,0,0},
  371.     { NM_ITEM,        "Quit",        "Q",    0,0,0},
  372.  
  373.     { NM_TITLE,        "Options",    NULL,    0,0,0},
  374.     { NM_ITEM,        "Reset counters", "C",0,0,0},
  375.     { NM_ITEM,        "Watch GLOBAL",      "G",0,0,0},
  376.     { NM_ITEM,        "Watch Task.....","T",0,0,0},
  377.  
  378.     { NM_TITLE,        "Libraries A-I",NULL,0,0,0} };
  379.  
  380. //    { NM_END,        NULL,        NULL,    0,0,0} };
  381.  
  382. char version[]="$VER: HeartBeat 1.0 ©LVA (19/MAY/94)";
  383.  
  384. /**************************************************************************
  385. ** Here's the main program.
  386. **
  387. ** Basically:
  388. **    - load and parse all .fd files from the FD: directory.
  389. **    - bring up main function selection window (generate menustrip)
  390. **    - accumulate function selections in the "monitored functions" window
  391. **    - allow users to switch between global and Task snooping, set argument
  392. **      register traps, etc...
  393. **
  394. ** The main event loop needs some explaining:
  395. ** We do a combined Wait() for two sources:
  396. **  1) timer.device timeouts
  397. **  2) Intuition IntuiMessages
  398. ** The timer.device is used instead of INTUITICKS because we want the counters
  399. ** output window to continue updating when another non-HeartBeat window becomes
  400. ** the active one. (INTUITICKS stop when your window is deactivated).
  401. **
  402. ** All windows are hooked into the same message port which in turn generates
  403. ** (and uses) just one signal. That's why the code uses ModifyIDCMP() and
  404. ** messes around with the Window->UserPort field.
  405. **
  406. ** When windows other than the main function window (the window listing all
  407. ** function in a particular library) are opened, input to other windows is
  408. ** not blocked (IDCMP loop still collects from all sources).
  409. ****************************************************************************/
  410.  
  411. void main (void) {
  412.  
  413. struct RDArgs        *rdargs;
  414. struct IntuiMessage *msg;
  415. ULONG msgtype;
  416. ULONG signals,timeout_signal,Intevent_signal;
  417.  
  418.     if ( ((struct Library*)SysBase)->lib_Version < 36) {
  419.         printf("HeartBeat needs AmigaDOS 2.0 (V36+)... Sorry!\n");
  420.         exit(10);
  421.     }
  422.  
  423. // Check command line options.
  424.  
  425.     if (! (rdargs = ReadArgs("FORCE/S,VERBOSE/S", (ULONG*) &options, NULL))) {
  426.         printf("Amiga HeartBeat written by Laurence Vanhelsuwé © April 1992\n");
  427.         printf("HeartBeat is a system call monitoring utility.\n");
  428.         printf("Type HART ? for a full syntax template.\n");
  429.         exit(5);
  430.     }
  431.     FreeArgs(rdargs);
  432.  
  433. // Open libraries, init arrays, memory pools, etc...
  434.     if (!init_program()) exit(50);
  435.  
  436. // From the standard .fd (function definitions) files, get all the info
  437. // about system calls that we need.
  438.     find_function_info();
  439.  
  440. // bring up main function selection window with its menus
  441.     if (!popup_funcwindow()) {
  442.         printf("Failed to open main window (need at least %d*%d Workbench)\n",
  443.                 WINWIDTH, WINHEIGHT+16);
  444.         cleanup();
  445.     }
  446.  
  447.     curlib = &libs[0];            // curlib global for further references
  448.     display_functions();        // 1st library is default
  449.  
  450. // cache the two possible signals that we can receive
  451.     timeout_signal  = 1<<timerport->mp_SigBit;
  452.     Intevent_signal = 1<<IDCMPport->mp_SigBit;
  453.  
  454. // Send initial timeout request to timer.device
  455. // (provides refresh interrupts)
  456.     timereq.tr_time.tv_secs    = 0;
  457.     timereq.tr_time.tv_micro   = 1000000/REFRESH_FREQ;    // MICRO != MILLI
  458.     timereq.tr_node.io_Command = TR_ADDREQUEST;
  459.     SendIO((struct IORequest *) &timereq);                // asynchronous IO !
  460.  
  461.     quit_me = FALSE;        // user hasn't clicked on CLOSE gadget yet...
  462.  
  463.     while (!quit_me) {
  464.  
  465.     // Wait for an Intuition event or a Timer device timeout (or both simult.)
  466.         signals = Wait( Intevent_signal | timeout_signal);
  467.  
  468.         if (signals & timeout_signal) {        // .... ping !
  469.             GetMsg(timerport);                // dequeue msg (is just an ACK)
  470.             timereq.tr_time.tv_secs    = 0;
  471.             timereq.tr_time.tv_micro   = 1000000/REFRESH_FREQ;
  472.             timereq.tr_node.io_Command = TR_ADDREQUEST;
  473.             timereq.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  474.             SendIO((struct IORequest *) &timereq);    // ... pong !
  475.  
  476.             refresh_counters();                // refresh counters window
  477.         }
  478.  
  479.         // For Intuition Messages use the gadtools GetMsg/ReplyMsg variants
  480.         // so that gadtools can intercept gadget clicks which it (and not we)
  481.         // should process (e.g. for CYCLE_KIND or LISTVIEW_KIND gadgets !).
  482.  
  483.         if (signals & Intevent_signal) {
  484.             while (msg = GT_GetIMsg(IDCMPport)) {
  485.  
  486.                   msgtype    = msg->Class;    // copy Message fields and
  487.                 msgcode    = msg->Code;
  488.                 mousex    = msg->MouseX;
  489.                 mousey    = msg->MouseY;
  490.                 IAddr    = msg->IAddress;
  491.  
  492.                 GT_ReplyIMsg(msg);        // reply swiftly
  493.  
  494. #ifdef    DEBUGX
  495. printf("IDCMP MSGTYPE:%8lx (CODE:%8lx) ", msgtype, msgcode);
  496.                 switch (msgtype) {
  497.                     case CLOSEWINDOW:    printf("CLOSEWINDOW\n"); break;
  498.                     case ACTIVEWINDOW:    printf("ACTIVEWINDOW\n"); break;
  499.                     case MENUPICK:        printf("MENUPICK:\n"); break;
  500.                     case MOUSEMOVE:        printf("MOUSEMOVE:\n"); break;
  501.                     case MOUSEBUTTONS:    printf("MOUSEBUTTONS\n"); break;
  502.                     case VANILLAKEY:    printf("VANILLAKEY\n"); break;
  503.                     case GADGETUP:        printf("GADGETUP:\n"); break;
  504.                     case INTUITICKS:    printf("INTUITICKS\n"); break;
  505.                     case REFRESHWINDOW:    printf("REFRESHWINDOW\n"); break;
  506.                     default:            printf("-- UNKNOWN --\n");
  507.                 }
  508. #endif
  509.                 switch (msgtype) {
  510.                     case CLOSEWINDOW:    handle_quit();                    break;
  511.                     case ACTIVEWINDOW:    handle_activation();            break;
  512.                     case MENUPICK:        handle_menuselection(msgcode);    break;
  513.                     case MOUSEMOVE:        handle_mousemove();                break;
  514.                     case MOUSEBUTTONS:    handle_click();                    break;
  515.                     case VANILLAKEY:    handle_keypress( (char) msgcode); break;
  516.                     case GADGETUP:        handle_gadgets();                break;
  517.                     case INTUITICKS:    break;
  518.                     case REFRESHWINDOW:    GT_BeginRefresh((struct Window*)IAddr);
  519.                                         GT_EndRefresh((struct Window*)IAddr, TRUE);
  520.                                         break;
  521.                     default:
  522.                         printf("Unknown IDCMP MSGTYPE:%x (CODE:%x)\n", msgtype, msgcode);
  523.                 }
  524.             }    // WHILE MESSAGES FROM A WINDOW
  525.         }        // IF Intuition event...
  526.     }            // WHILE NOT QUITTING
  527.  
  528.     // At this stage a timout is ALWAYS outstanding so wait for it to come back.
  529.  
  530.     WaitPort(timerport); GetMsg(timerport);
  531.  
  532.     cleanup();        // finally before returning to the CLI...
  533. }
  534.  
  535. //-------------------------------------------------------------------------
  536. // Here follows the various IntuiMessage handlers.
  537. // The handlers themselves further branch to the required logic depending
  538. // on the "state" of HeartBeat. This state is usually directly related to
  539. // which HeartBeat window is currently active.
  540. //
  541. // The IntuiMessage ACTIVEWINDOW therefore is the main cause of state switching.
  542. //-------------------------------------------------------------------------
  543.  
  544.  
  545. //-------------------------------------------------------------------------
  546. // We received a CLOSEWINDOW event. This can come from any of our windows,
  547. // so close requested window only (if main window: signal kill application).
  548. //-------------------------------------------------------------------------
  549.  
  550. void handle_quit(void) {
  551.  
  552.     switch (app_state) {
  553.  
  554.         //-----------------------------------------------------------------
  555.         case FUNCWINDOW:
  556.             if (!monwindow && !taskwindow && !regswindow)
  557.                 quit_me = TRUE;
  558.             break;
  559.  
  560.         //-----------------------------------------------------------------
  561.         case MONWINDOW:
  562.             unpatch_functions();        // unpatch from system !
  563.  
  564.             CloseWindowSafely(monwindow); monwindow = NULL;
  565.  
  566.             if (curlib) display_functions();    // refresh func names list
  567.  
  568.             // app_state = FUNCWINDOW; break;
  569.             ActivateWindow(window);        // this is safer way to achieve same
  570.             break;
  571.  
  572.         //-----------------------------------------------------------------
  573.         case REGSWINDOW:
  574.             kill_regsReq_window();        // done with window: get rid of it
  575.  
  576.             //    app_state = FUNCWINDOW;    // revert to neutral state
  577.             ActivateWindow(window);        // this is safer way to achieve same
  578.             break;
  579.  
  580.         //-----------------------------------------------------------------
  581.         case TASKWINDOW:
  582.             kill_taskReq_window();        // done with window: get rid of it
  583.  
  584.             //    app_state = FUNCWINDOW;    // revert to neutral state
  585.             ActivateWindow(window);        // this is safer way to achieve same
  586.             break;
  587.  
  588.         //-----------------------------------------------------------------
  589.         default: printf("QUIT BUG: appi in unknown state %d\n", app_state);
  590.     }
  591. }
  592. //-------------------------------------------------------------------------
  593. // An ACTIVEWINDOW event has arrived at our main IDCMP comms port.
  594. // To aid in determining which Gadgets get clicked or which window receives
  595. // a mouse click, we track which window is currently the actived one.
  596. //-------------------------------------------------------------------------
  597. void handle_activation(void) {
  598.  
  599.     switch (app_state) {
  600.  
  601.         case FUNCWINDOW:
  602.         case MONWINDOW:
  603.         case TASKWINDOW:
  604.         case REGSWINDOW:
  605.             if (IAddr == (APTR) window)        { app_state = FUNCWINDOW;} else
  606.             if (IAddr == (APTR) monwindow)    { app_state = MONWINDOW; } else
  607.             if (IAddr == (APTR) taskwindow) { app_state = TASKWINDOW;} else
  608.             if (IAddr == (APTR) regswindow) { app_state = REGSWINDOW;}
  609.             break;
  610.  
  611.         default: printf("ACTIV BUG: appi in unknown state %d\n", app_state);
  612.     }
  613. }
  614. //-------------------------------------------------------------------------
  615. // A MENUPICK event has arrived. Only the main function window can generate
  616. // this, but other windows might also be around so watch out for that.
  617. //-------------------------------------------------------------------------
  618. void handle_menuselection(SHORT menu) {
  619.  
  620. int library;
  621. int err;
  622.  
  623.     switch (MENUNUM(menu)) {
  624.         //----------------------------------------------------------------
  625.         case PROJECT_MENU:
  626.             switch (ITEMNUM(menu)) {
  627.                 //--------------------------------------------------------
  628.                 case NEW_ITEM:
  629.                     if (!monwindow) break;        // only if monitor window exists
  630.  
  631.                     unpatch_functions();        // unpatch from system !
  632.                     CloseWindowSafely(monwindow); monwindow = NULL;
  633.  
  634.                     break;
  635.                 //--------------------------------------------------------
  636.                 case LOAD_ITEM:
  637.                     err = load_funclist();
  638.                     switch (err) {
  639.                         case ERR_OK:
  640.                             break;
  641.                         case ERR_BADFILE:
  642.                             quick_msg("Your selected file isn't a HeartBeat file!","Oopps..");
  643.                             break;
  644.                         case ERR_DOSERR:
  645.                             quick_msg("Could not open your file!","Hmmm..");
  646.                             break;
  647.                         default:
  648.                             quick_msg("**!! UNKNOWN ERROR IN LOAD_ITEM","arggh..");
  649.                             break;
  650.                     }
  651.                     break;
  652.                 //--------------------------------------------------------
  653.                 case SAVE_ITEM:
  654.                     if (monwindow) {
  655.                         err = save_funclist();
  656.                         switch (err) {
  657.                             case ERR_OK:
  658.                                 break;
  659.                             case ERR_DOSERR:
  660.                                 quick_msg("Couldn't save session!","Pitty");
  661.                                 break;
  662.                             default:
  663.                                 quick_msg("**!! UNKNOWN ERROR IN LOAD_ITEM","arggh..");
  664.                                 break;
  665.                         }
  666.                     } else {
  667.                         quick_msg("No monitoring session to save!","Sorry..");
  668.                     }
  669.                     break;
  670.                 //--------------------------------------------------------
  671.                 case ABOUT_ITEM:
  672.                     popup_About_req();
  673.                     break;
  674.                 //--------------------------------------------------------
  675.                 case QUIT_ITEM:
  676.                     if (!monwindow && !taskwindow && !regswindow)
  677.                         quit_me = TRUE;
  678.                     break;
  679.             }
  680.             break;
  681.         //----------------------------------------------------------------
  682.         case OPTIONS_MENU:
  683.             switch (ITEMNUM(menu)) {
  684.                 //--------------------------------------------------------
  685.                 case GLOBAL_ITEM:
  686.                     reset_counters();
  687.                     SNOOP_TASK = NULL;
  688.                     if (monwindow)
  689.                         SetWindowTitles(monwindow,"Monitored functions (GLOBAL)", (char*) -1);
  690.                     break;
  691.                 //--------------------------------------------------------
  692.                 case TASK_ITEM:
  693.                     if (!taskwindow) {
  694.                         // pop up window with list of Tasks. User selection
  695.                         // will come to us via standard gadget clicks, not
  696.                         // here !
  697.                         ask_task("Please select any Task.");
  698.                     } else {
  699.                         WindowToFront(taskwindow);
  700.                         ActivateWindow(taskwindow);
  701.                     }
  702.                     break;
  703.                 //--------------------------------------------------------
  704.                 case RESET_ITEM:
  705.                     reset_counters();
  706.                     break;
  707.             }
  708.             break;
  709.         //----------------------------------------------------------------
  710.         case LIBS_1_MENU:
  711.             library = ITEMNUM(menu);
  712.             curlib = &libs[library];    // curlib global for further references
  713.             display_functions();
  714.             break;
  715.         //----------------------------------------------------------------
  716.         case LIBS_2_MENU:
  717.             library = ITEMNUM(menu) + lowlibs;
  718.             curlib = &libs[library];
  719.             display_functions();
  720.             break;
  721.     }
  722. }
  723. //-------------------------------------------------------------------------
  724. // If mouse points at a new function, de-highlight old box and highlight new
  725. // one.
  726. // This has the effect of a cursor over the available functions.
  727. //-------------------------------------------------------------------------
  728.  
  729. void handle_mousemove(void) {
  730. SHORT boxx,boxy,monboxy;
  731.  
  732.     switch (app_state) {
  733.         //----------------------------------------------------------------
  734.         case MONWINDOW:
  735.             monboxy = (mousey-PANE_Y-1-12)/CHAR_HEIGHT;
  736.             // If mouse moved out of previous box area...
  737.             if (monboxy != oldmonboxy) {
  738.  
  739.                 // restrict legal box movements!
  740.  
  741.                 if ( monboxy >= 0 && monboxy < monitored ) {
  742.                     if (oldmonboxy != -1) {
  743.                         erase_monbox(0,oldmonboxy,(MAX_LABLEN+25)*CHAR_WIDTH);
  744.                     }
  745.  
  746.                     highlight_monbox(0,monboxy,(MAX_LABLEN+25)*CHAR_WIDTH);
  747.                     oldmonboxy = monboxy;
  748.                 }
  749.             }
  750.             break;
  751.         //----------------------------------------------------------------
  752.         case FUNCWINDOW:
  753.  
  754.             boxx = (mousex-PANE_X)/(MAX_LABLEN*CHAR_WIDTH);
  755.             boxy = (mousey-PANE_Y-1)/CHAR_HEIGHT;
  756.  
  757.             // If mouse moved out of previous box area...
  758.             if (boxx != oldboxx || boxy != oldboxy) {
  759.  
  760.                 if (boxx >= 0        &&            // restrict legal box movements!
  761.                     boxy >= 0        &&
  762.                     boxy < maxrows    &&
  763.                     (boxy + maxrows*boxx) < curlib->numfuncs) {
  764.  
  765.                         if (oldboxx != -1) {
  766.                             erase_box(oldboxx,oldboxy,(MAX_LABLEN*CHAR_WIDTH)-10);
  767.                         }
  768.  
  769.                         highlight_box(boxx,boxy, (MAX_LABLEN*CHAR_WIDTH)-10 );
  770.                         oldboxx = boxx;    oldboxy = boxy;
  771.                 }
  772.             }
  773.             break;
  774.         //----------------------------------------------------------------
  775.     }
  776. }
  777. //-------------------------------------------------------------------------
  778. // A MOUSEBUTTON event arrived.
  779. //
  780. // If in function window then add selected function to list of traced ones if
  781. // not already being traced.
  782. //
  783. // If in monitored functions window, see comment further down.
  784. //-------------------------------------------------------------------------
  785. void handle_click (void) {
  786.  
  787.     if (msgcode & 0x80) return;            // don't bother with release clicks
  788.  
  789.     switch (app_state) {
  790.  
  791.         //----------------------------------------------------------------
  792.         case FUNCWINDOW:
  793.  
  794.             if (oldboxx != -1) {        // don't select invalid funcs
  795.  
  796.             struct SysCall *syscall;    // define some very local variables
  797.             int funcnum;
  798.  
  799.                 funcnum = oldboxy + maxrows * oldboxx;
  800.                 syscall = ((struct SysCall *)curlib->funcslist.lh_Head) + funcnum;
  801.  
  802.                 // add function to list of tracked ones
  803.                 add_function(syscall);
  804.  
  805.                 // Once at least one function is being traced,
  806.                 // the option menu items become available
  807.                 OnMenu(window, FULLMENUNUM(OPTIONS_MENU,NOITEM,NOSUB));
  808.             }
  809.             break;
  810.  
  811.         //----------------------------------------------------------------
  812.         // A click in the monitoring window can mean two things:
  813.         //    a) user wants to define the input registers for a match
  814.         //    b) if the selected function has trapped and frozen its Task
  815.         //        un-freeze task by sending it a Signal()
  816.         //----------------------------------------------------------------
  817.  
  818.         case MONWINDOW:
  819.  
  820.             if (oldmonboxy != -1) {        // don't accept invalid funcs
  821.  
  822.             struct Context *cx;
  823.  
  824.                 cx = patched_calls[oldmonboxy]->ctxt;
  825.                 if (SNOOP_TASK && cx->frozen) {
  826.  
  827.                     Signal(SNOOP_TASK, 1<<24);    // de-freeze Task
  828.  
  829.                 } else {
  830.  
  831.                     selected_syscall = patched_calls[oldmonboxy];
  832.                     if (!regswindow) {
  833.  
  834.                         // pop up window with all 680x0 registers. User changes
  835.                         // will come to us via standard gadget clicks, not here !
  836.  
  837.                         ask_register_info("Define Arg Registers", selected_syscall->ctxt);
  838.  
  839.                     } else {
  840.                         WindowToFront(regswindow);
  841.                         ActivateWindow(regswindow);
  842.                     }
  843.                 }
  844.             }
  845.             break;
  846.         //----------------------------------------------------------------
  847.         case TASKWINDOW:
  848.         case REGSWINDOW: break;
  849.  
  850.         default:
  851.             printf("CLICK BUG: appi in unknown state %d\n", app_state);
  852.     }
  853. }
  854. //-------------------------------------------------------------------------
  855. // **!! At this point HartBeat doesn't use individual key presses.
  856. //-------------------------------------------------------------------------
  857. void handle_keypress(char key) {
  858.     //    printf("Key pressed: %c\n", key);
  859. }
  860. //-------------------------------------------------------------------------
  861. // A GADGETUP event arrived. Meaning any of our Gadgets scattered around
  862. // multiple Windows has been clicked.
  863. //-------------------------------------------------------------------------
  864.  
  865. #define    TSKLST_LIST        0
  866. #define    TSKLST_USE        1
  867. #define    TSKLST_CANCEL    2
  868.  
  869. #define    REGLST_CYCLE    32
  870. #define    REGLST_USE        33
  871. #define    REGLST_CANCEL    34
  872.  
  873. void handle_gadgets(void) {
  874. USHORT gid;
  875.  
  876.     gid = ((struct Gadget*)IAddr)->GadgetID;
  877.  
  878.     switch (app_state) {
  879.         //-----------------------------------------------------------------
  880.         case REGSWINDOW:
  881.             switch (gid) {
  882.                 //---------------------------------------------------------
  883.                 case REGLST_USE: {
  884.                     struct Gadget *gad;
  885.                     struct Context *ctxt;
  886.                     char *str;
  887.                     int regs,val;
  888.  
  889.                     // -> 1st string Gadget (Skip Gadtools "context" gadget)
  890.                     gad = regsReqGads->NextGadget; ctxt = selected_syscall->ctxt;
  891.                     
  892.                     for(regs=0; regs<32; regs++) {
  893.  
  894.                         str = ((struct StringInfo*)gad->SpecialInfo)->Buffer;
  895.  
  896.                         if (*str == '$') {
  897.                             if (!sscanf(str+1,"%lx", &val)) val = -1;
  898.                         } else {
  899.                             if (!sscanf(str,"%ld", &val)) val = -1;
  900.                         }
  901.  
  902.                         if (regs&1)                            // if gadID is odd,
  903.                             ctxt->regmasks[regs>>1] = val;    // it's a mask
  904.                         else                                // else
  905.                             ctxt->regvals[regs>>1] = val;    // it's a register
  906.  
  907.                         gad = gad->NextGadget;            // goto next string gadg
  908.  
  909.                      }    // end of for
  910.                     }    // end of compound statement
  911.  
  912.                         // Fall thru to kill window
  913.                 //---------------------------------------------------------
  914.                 case REGLST_CANCEL:
  915.                     kill_regsReq_window();    // done with window: get rid of it
  916.  
  917.                     //    app_state = FUNCWINDOW;    // revert to neutral state
  918.                     ActivateWindow(window);    // this is safer way to achieve same
  919.                     break;
  920.                 //---------------------------------------------------------
  921.                 case REGLST_CYCLE:
  922.                     selected_syscall->ctxt->freeze = (msgcode==1) ? -1 : 0 ;
  923.                     selected_syscall->ctxt->frozen = FALSE;
  924.                     break;
  925.                 //---------------------------------------------------------
  926.             }
  927.             break;
  928.         //-----------------------------------------------------------------
  929.         case TASKWINDOW:
  930.             switch ( ((struct Gadget*)IAddr)->GadgetID) {
  931.                 //---------------------------------------------------------
  932.                 case TSKLST_LIST:
  933.                     task_num = msgcode;        // register which Task user selected
  934.                     break;
  935.                 //---------------------------------------------------------
  936.                 case TSKLST_USE:
  937.                     watch_task(task_num);    // using previously recorded selection
  938.                     SetWindowTitles(monwindow,"Monitored functions (TASK)", (char*) -1);
  939.                     reset_counters();        // switch to snoop new Task
  940.                         // Fall thru to kill window
  941.                 //---------------------------------------------------------
  942.                 case TSKLST_CANCEL:
  943.                     kill_taskReq_window();    // done with window: get rid of it
  944.  
  945.                     //    app_state = FUNCWINDOW;    // revert to neutral state
  946.                     ActivateWindow(window);    // this is safer way to achieve same
  947.                     break;
  948.             }
  949.             break;
  950.         //-----------------------------------------------------------------
  951.         case FUNCWINDOW:
  952.         case MONWINDOW:
  953.         default: printf("GADGET BUG: appi in unknown state %d\n", app_state);
  954.     }
  955. }
  956. //-------------------------------------------------------------------------
  957. // List all functions of a selected library in neat columns in the main window.
  958. // Display all functions which don't point to ROM in INVERSE VIDEO.
  959. //-------------------------------------------------------------------------
  960.  
  961. void display_functions(void) {
  962.  
  963. int i,len;
  964. struct SysCall *func;
  965. ULONG vector;
  966.  
  967.     SetDrMd(rp,JAM1);                        // normal drawing mode
  968.     SetAPen(rp,0);                            // use background pen to wipe
  969.     RectFill(rp, PANE_X, PANE_Y, winwidth-5, winheight-3); // previous functions off
  970.  
  971.     SetAPen(rp,1);                            // use text pen
  972.     maxrows = (winheight-18)/CHAR_HEIGHT;
  973.  
  974.         // point to first function node
  975.     func = (struct SysCall*) curlib->funcslist.lh_Head;
  976.  
  977.     i = 0;                                    // start index from 0
  978.     while (func->func_node.ln_Succ) {
  979.             // limit label length to fit in column
  980.         len = (func->namelen > MAX_LABLEN ? MAX_LABLEN : func->namelen);
  981.  
  982.         Move(rp, PANE_X +    (i/maxrows)*MAX_LABLEN*CHAR_WIDTH,
  983.                  PANE_Y + 6 +(i%maxrows)*CHAR_HEIGHT);
  984.  
  985.             // find out where function points to currently.
  986.             // if not the ROM then highlight function name.
  987.         vector = *((ULONG*)(((char*)func->parent_lib) + func->func_LVO +2));
  988.         if (vector < 0xF80000 || vector >0xFFFFFC) {
  989.             SetDrMd(rp,INVERSVID);                    // highlight function
  990.             Text(rp, func->funcname, len);
  991.             SetDrMd(rp,JAM1);                        // revert to normal mode
  992.         } else {
  993.             Text(rp, func->funcname, len);
  994.         }
  995.  
  996.         func = (struct SysCall*) func->func_node.ln_Succ;
  997.         i++;
  998.     }
  999.  
  1000.     app_state = FUNCWINDOW;                    // functions are now selectable...
  1001.     oldboxx = -1;                            // invalidate last box
  1002. }
  1003. //-------------------------------------------------------------------------
  1004. // User selected the "About..." option in the Project menu.
  1005. // Give him some info.
  1006. //-------------------------------------------------------------------------
  1007. void popup_About_req(void) {
  1008.  
  1009. static struct EasyStruct aboutES = {
  1010.     sizeof (struct EasyStruct),
  1011.     0,
  1012.     "HeartBeat Program Information Broadcast", "\
  1013. HeartBeat allows you to snoop on any Amiga system calls.\n\
  1014. To select functions to be tracked, first select any Library,\n\
  1015. Device or Resource from the Libraries menus and then click\n\
  1016. on any function(s) you wish to snoop on.\n\
  1017. WARNING: Take it easy with Exec... or be punished !\n\
  1018. e.g. SuperVisor(), SumLibrary(), CacheClearU(), ...\n\
  1019. \n\
  1020. HeartBeat was written by Laurence Vanhelsuwé.\n\
  1021. You can contact the author at the following address:\n\
  1022. \n\
  1023. Christinastraat 105\n\
  1024. B-8400 Oostende\n\
  1025. Belgium\n\
  1026. Europe",
  1027.  
  1028.     "Thanks|Great|WILLCO|Yeah|OK",
  1029. };
  1030.  
  1031.     EasyRequest(window, &aboutES, NULL);
  1032. }
  1033. //-------------------------------------------------------------------------
  1034. // User wants to load a previously saved monitoring session.
  1035. //-------------------------------------------------------------------------
  1036. #define    BUFLEN    60                    // size of line buffer
  1037.  
  1038. int load_funclist (void) {
  1039.  
  1040. struct SysCall *scall;
  1041. char libnamebuf[BUFLEN],funcnamebuf[BUFLEN];
  1042. char *fname, *ptr;
  1043. FILE *fhandle;
  1044. BOOL added;
  1045.  
  1046.     // Ask user where to load session information from.
  1047.  
  1048.     fname = get_filename("Session filename to LOAD");
  1049.     if (!fname) return ERR_NOMEM;
  1050.  
  1051.     fhandle = fopen(fname,"r"); if (!fhandle) return ERR_DOSERR;
  1052.  
  1053.     // Check that file is a HeartBeat file.
  1054.     fgets(libnamebuf, BUFLEN, fhandle);
  1055.  
  1056.     if (strcmp(libnamebuf, HB_SIGNATURE)) {
  1057.         fclose(fhandle);
  1058.         return ERR_BADFILE;
  1059.     }
  1060.  
  1061.     // Read in session file until EOF is encountered or until func list is full
  1062.     do {
  1063.         ptr = fgets(libnamebuf ,BUFLEN, fhandle);
  1064.         ptr = fgets(funcnamebuf,BUFLEN, fhandle);
  1065.  
  1066.         if (ptr) {
  1067.             scall = find_func(libnamebuf, funcnamebuf);
  1068.             if (scall) {
  1069.                 added = add_function(scall);
  1070.             } else {
  1071. //                printf("%s, %s NOT VISISBLE !\n", libnamebuf, funcnamebuf);
  1072.             }
  1073.         }
  1074.     } while (ptr && added);
  1075.  
  1076.     fclose(fhandle);
  1077.  
  1078.     // Once at least one function is being traced,
  1079.     // the option menu items can become available
  1080.     OnMenu(window, FULLMENUNUM(OPTIONS_MENU,NOITEM,NOSUB));
  1081.  
  1082.     return ERR_OK;
  1083. }
  1084.  
  1085. //-------------------------------------------------------------------------
  1086. // Check whether a function traced in a previous session is again visible.
  1087. // If so, return its SysCall struct ptr.
  1088. //-------------------------------------------------------------------------
  1089. struct SysCall *find_func( char *libname, char *funcname) {
  1090.  
  1091. struct SysCall *syscall;
  1092.  
  1093.     strip_lf(libname); strip_lf(funcname);
  1094.  
  1095.     for (libnum=0; libnum<numlibs; libnum++) {                // chk all lib slots
  1096.         if (libs[libnum].openhandle) {                        // if loaded..
  1097.             if (!strcmp(libs[libnum].libname, libname)) {    // and same as arg
  1098.                 syscall = (struct SysCall*) libs[libnum].funcslist.lh_Head;
  1099.                 while (syscall->func_node.ln_Succ) {        // traverse func list
  1100.  
  1101.                     if (!strcmp (syscall->funcname, funcname))    // if func exists
  1102.                         return syscall;                        // tell caller
  1103.  
  1104.                     syscall = (struct SysCall*) syscall->func_node.ln_Succ;
  1105.  
  1106.                 }    // while functions on library function list
  1107.             }        // only if same library as argument
  1108.         }            // only for loaded libraries
  1109.     }                // while libraries
  1110.  
  1111.     return NULL;
  1112. }
  1113. //-------------------------------------------------------------------------
  1114. // User wants to save his current monitoring sessions for later.
  1115. //-------------------------------------------------------------------------
  1116. int save_funclist (void) {
  1117.  
  1118. struct SysCall **syscall = patched_calls;    // point to array of SysCall ptrs
  1119.  
  1120. char *fname;
  1121. int i;
  1122. FILE *fhandle;
  1123.  
  1124.     // Ask user where to save session information to.
  1125.  
  1126.     fname = get_filename("Session filename to SAVE");
  1127.     if (!fname) return ERR_NOMEM;
  1128.  
  1129.     // Open file and print file header
  1130.     fhandle = fopen(fname,"w");
  1131.     fprintf(fhandle, HB_SIGNATURE);
  1132.  
  1133.     // Dump session information to file
  1134.     for(i=1; i <= monitored; i++) {
  1135.         fprintf(fhandle, "%s\n", (*syscall)->parent_lib->lib_Node.ln_Name);
  1136.         fprintf(fhandle, "%s\n", (*syscall)->funcname);
  1137.         syscall++;                            // goto next SysCall structure
  1138.     }
  1139.  
  1140.     fclose(fhandle);
  1141.  
  1142.     return ERR_OK;
  1143. }
  1144.  
  1145. //-------------------------------------------------------------------------
  1146. // Generic Filename request.
  1147. //-------------------------------------------------------------------------
  1148. char * get_filename(char * windowmsg) {
  1149.  
  1150. struct FileRequester *fr;
  1151. char *ptr;
  1152. BOOL result;
  1153.  
  1154.     fr = AllocAslRequestTags(ASL_FileRequest, NULL);
  1155.     if (!fr) return NULL;
  1156.  
  1157. // Ask user what filename he wants to use
  1158.  
  1159.     result = AslRequestTags(fr,
  1160. //            ASLFR_TitleText,windowmsg,    // need a newer INCLUDE file : AARRGH
  1161.  
  1162.             ASL_Hail,windowmsg,            // using obsolete version TAG instead **!!
  1163.  
  1164.             NULL);
  1165.  
  1166.     if (!result) return NULL;
  1167.  
  1168.     if (fr->rf_Dir) {        // if there's a directory component..
  1169.  
  1170.         ptr = stpcpy(filename_buf, fr->rf_Dir);        // 1st copy path
  1171.  
  1172.         if (*(ptr-1) != ':')
  1173.             *ptr++ = '/';                            // separate path from file
  1174.  
  1175.         stpcpy(ptr, fr->rf_File);                    // then append filename
  1176.  
  1177.     } else {
  1178.         strcpy(filename_buf, fr->rf_File);
  1179.     }
  1180.  
  1181.     FreeAslRequest(fr);
  1182.  
  1183.     return filename_buf;
  1184. }
  1185. //-------------------------------------------------------------------------
  1186. // This is a generic routine to bring up small message requesters.
  1187. //-------------------------------------------------------------------------
  1188. void quick_msg (char *message, char *exit) {
  1189.  
  1190. struct EasyStruct quickES;
  1191.  
  1192.     quickES.es_StructSize    = sizeof (struct EasyStruct);
  1193.     quickES.es_Flags        = 0;
  1194.     quickES.es_Title        = "HeartBeat says...";
  1195.     quickES.es_TextFormat    = message;
  1196.     quickES.es_GadgetFormat    = exit;
  1197.  
  1198.     EasyRequest(window, &quickES, NULL);
  1199. }
  1200. //-------------------------------------------------------------------------
  1201. // Most Amiga systems should have a directory full of ".fd" files containing
  1202. // Amiga system function definitions.
  1203. // Go and find this directory and extract as much possible information from
  1204. // these files.
  1205. //
  1206. // An example of real .FD file follows
  1207. /*
  1208.  
  1209. * "battclock.resource"
  1210. ##base _BattClockBase
  1211. ##bias 6
  1212. ##public
  1213. ResetBattClock()()
  1214. ReadBattClock()()
  1215. WriteBattClock(time)(d0)
  1216. ##private
  1217. battclockPrivate1()()
  1218. battclockPrivate2()()
  1219. ##end
  1220.  
  1221. */
  1222. //-------------------------------------------------------------------------
  1223. void find_function_info(void) {
  1224.  
  1225. struct FileCache *fc;
  1226. char *fname;
  1227. int i;
  1228.  
  1229.     // Find out how many .fd files in FD: directory
  1230.     num_fdfiles = calc_num_fd_files();
  1231.     if (VERBOSE) printf("FD: directory contains %d libraries.\n", num_fdfiles);
  1232.  
  1233.     if (num_fdfiles > MAX_LIBS) {
  1234.         printf("Your FD: Directory contains too many entries for HeartBeat (%d > %d)\n",
  1235.             num_fdfiles, MAX_LIBS);
  1236.         cleanup();
  1237.     }
  1238.  
  1239.     // Move to FD: directory so we can use short relative filanemes.
  1240.     chdir("FD:");
  1241.  
  1242.     fc = fd_caches;                        // starting from 1st .fd file
  1243.     fname = FdDirCache.filebuf;
  1244.     total_funcs = libnum = 0;            // starting from library array slot #0
  1245.  
  1246.     for (i=0; i< num_fdfiles; i++) {
  1247.         if (!load_file(fname, fc)) {
  1248.             if (VERBOSE) printf("Couldn't cache %s !\n", fname);
  1249.             cleanup();
  1250.         }
  1251.         fc->filename = fname;            // store name of cached file
  1252.  
  1253.         // parse .FD file and extract all function call information
  1254.         if (!process_fd_file(fc)) {
  1255.             if (VERBOSE) printf("File %s couldn't be parsed.\n", fc->filename);
  1256.         } else {
  1257.             libnum++;                    // done one more library...
  1258.         }
  1259.  
  1260.         fc++;                            // point to next file cache
  1261.         fname += 1+ strlen(fname);        // point to next .fd filename
  1262.     }
  1263.  
  1264.     if (VERBOSE)
  1265.         printf("Counted %d functions in %d libraries\n", total_funcs, libnum);
  1266.  
  1267.     // from now on, the remainder of the node pool is used to allocate
  1268.     // function contexts. (node_pool is used to reset the ctxt_pool ptr).
  1269.     ctxt_pool = (void*) node_pool;
  1270.  
  1271.  
  1272.     // set the library array index ceiling
  1273.     numlibs = libnum;
  1274. }
  1275. //-------------------------------------------------------------------------
  1276. // Find howmany .fd files there are in the FD: directory.
  1277. //-------------------------------------------------------------------------
  1278. int calc_num_fd_files( void ) {
  1279.  
  1280. int match;
  1281. char *matchptr;        // ptr to be filled in by stcpm()
  1282. register int lines;
  1283. register char * ptr;
  1284. BOOL ret;
  1285.                                         // Let "LIST" do all the hard work.
  1286.     ret = Execute("C:LIST >T:FDLIST FD:#?.fd nohead quick",0,0);
  1287.     if (!ret) {
  1288.         printf("Could not 'LIST' your FD: directory.\n");
  1289.         cleanup();
  1290.     }
  1291.                                         // Let "SORT" do some more hard work.
  1292.     ret = Execute("C:SORT T:FDLIST TO T:FDL2",0,0);
  1293.     if (!ret) {
  1294.         printf("Could not 'SORT' filenames.\n");
  1295.         cleanup();
  1296.     }
  1297.  
  1298.     if (! load_file("T:FDL2", &FdDirCache)) {
  1299.         printf("Failed to load LIST output 'T:FDL2'\n");
  1300.         cleanup();
  1301.     }
  1302.  
  1303.     ptr = FdDirCache.filebuf;            // go analyze LIST's output.
  1304.     lines = 0;
  1305.     while (*ptr) {                        // while not EOF
  1306.         if (*ptr++ == LF) {                // count lines
  1307.             lines++;
  1308.         }
  1309.     }
  1310.  
  1311.     // Turn filename list into list of C-strings
  1312.     text_to_heap (&FdDirCache);
  1313.  
  1314.     // Now check first line and make sure it contains the substring ".fd"
  1315.     // If not, then list probably printed an error message, so we quit.
  1316.     // do an unanchored pattern match (Lattice function)
  1317.  
  1318.     ptr = FdDirCache.filebuf;
  1319.     match = stcpm(ptr, ".fd",&matchptr);
  1320.  
  1321.     if (!match) {
  1322.         printf("LIST of FD: directory failed.\n");
  1323.         cleanup();
  1324.     }
  1325.  
  1326.     // if LIST went OK then # of lines == # of .fd files
  1327.     return lines;
  1328. }
  1329. //-------------------------------------------------------------------------
  1330. // User just clicked the currently highlighted system function name.
  1331. // Add this system call to the list of traced ones and stretch Monitoring
  1332. // window to hold extra function line.
  1333. //
  1334. // return FALSE if we can't accept any more functions.
  1335. //-------------------------------------------------------------------------
  1336.  
  1337. BOOL add_function (struct SysCall *syscall) {
  1338.  
  1339. char addr_str[]="$0000FFFF   ";        // output buf for bin2hex conversion
  1340. short oldheight;
  1341. struct NewWindow *NW;
  1342. struct Context *cx;
  1343. register USHORT *wedge,*code;
  1344. APTR newpatch;
  1345. int dy,len;
  1346. register int i;
  1347.  
  1348.     if (syscall->ctxt) return TRUE;            // don't bother patching same func twice!!
  1349.  
  1350.     if (monitored == MAX_PATCHED) return FALSE;    // or exceeding max number
  1351.  
  1352.         // If function call is the very first one and Window therefore does
  1353.         // not exist yet, create it first.
  1354.  
  1355.     if (!monitored) {
  1356.  
  1357.         NW = &nw;
  1358.         NW->Title    = "Monitored Functions";
  1359.         NW->TopEdge = 30; NW->LeftEdge = 640-380;
  1360.         NW->Width    = PANE_X+48*CHAR_WIDTH; NW->Height = 27;
  1361.         NW->Flags    = WFLG_CLOSEGADGET|
  1362.                       WFLG_DEPTHGADGET|
  1363.                       WFLG_REPORTMOUSE|
  1364.                       WFLG_DRAGBAR;
  1365.  
  1366.         monwindow = OpenWindow(NW); if (!monwindow) return FALSE;
  1367.  
  1368.         monwindow->UserPort = IDCMPport;        // share global event MsgPort
  1369.         ModifyIDCMP(monwindow, IDCMP_SELECTION); // allow events from new window
  1370.  
  1371.         monrp = monwindow->RPort;
  1372.  
  1373.         Move (monrp, PANE_X, PANE_Y+6);
  1374.         SetDrMd(monrp, JAM1); SetAPen(monrp, 1);
  1375.         //Text (monrp, "   Called    Matched  Function", 30);
  1376.         //             "$0000FFFF  $0000FFFF  SuperVisor"
  1377.  
  1378.         Text (monrp,   " Called Matched   Address  Function", 35);
  1379.         //               "$00FFFF $00FFFF $07FFFFFF  SuperVisor"
  1380.  
  1381.         Move (monrp, PANE_X, PANE_Y+8);
  1382.         Draw (monrp, PANE_X+35*CHAR_WIDTH , PANE_Y+8);
  1383.     }
  1384.  
  1385.     oldheight = monwindow->Height;
  1386.     SizeWindow(monwindow, 0, CHAR_HEIGHT);
  1387.     Delay(7);    // Wait for Intuition to actually do the async sizing
  1388.  
  1389.         // Check that window actually stretched correctly.
  1390.         // If it didn't (coz window's touching bottom of Workbench) then
  1391.         // move window up and try again (If it fails again: quit)
  1392.  
  1393.     dy = monwindow->Height - oldheight;
  1394.     if (dy != CHAR_HEIGHT) {
  1395.         oldheight = monwindow->Height;
  1396.         MoveWindow(monwindow, 0, -(CHAR_HEIGHT-dy));
  1397.         SizeWindow(monwindow, 0, CHAR_HEIGHT-dy);
  1398.         Delay(7);
  1399.         if (oldheight != (monwindow->Height -(CHAR_HEIGHT-dy))) return FALSE;
  1400.     }
  1401.  
  1402. // OK. At this point we can definitely patch this function.
  1403. // Print function information in window. (previous Function address printing
  1404. // is done lower down after SetFunction() )
  1405.  
  1406.     SetDrMd(monrp, JAM1); SetAPen(monrp, 1);
  1407.     Move(monrp, PANE_X + (27*CHAR_WIDTH), PANE_Y +10 + (monitored+1) * CHAR_HEIGHT);
  1408.     Text(monrp, syscall->funcname, syscall->namelen);
  1409.  
  1410.     
  1411.     patched_calls[monitored++] = syscall; // track call in array of patched ones
  1412.  
  1413.     cx = ctxt_pool++;                        // allocate a Context
  1414.  
  1415.     if ( ((char*)ctxt_pool) > ((char*)pool_base)+POOL_SIZE-200)
  1416.         printf("About to blow pool ! **BUG**\n");
  1417.  
  1418.     init_context(cx);                        // fill in regs, zero counters
  1419.     syscall->ctxt = cx;                        // give SysCall struct a Context
  1420.  
  1421.     wedge = (USHORT*) ctxt_pool;            // spot for wedge code
  1422.     newpatch = (APTR) wedge;                // remember start address
  1423.  
  1424.     code = (USHORT*) WEDGE;                    // R/O image of wedge code
  1425.     i = *(code-1);                            // is this many WORDs long
  1426.     while (i--) {
  1427.         *wedge++ = *code++;                    // Copy wedge routine
  1428.     }
  1429.     ctxt_pool = (struct Context*) wedge;    // update free memory ptr
  1430.  
  1431.     // Now patch library and fill in normal func address and counter address
  1432.     // in patch.
  1433.     
  1434.     Disable();
  1435.  
  1436.     cx->stdvector = SetFunction(syscall->parent_lib, syscall->func_LVO, newpatch);
  1437.  
  1438. #define    patch_wedge(wedge,offs,patch)    \
  1439.     *((ULONG*)((wedge)+ *(((UWORD*)WEDGE)-offs))) = (ULONG)patch;
  1440.  
  1441.     patch_wedge((UWORD*)newpatch, 2, cx->stdvector);    // JMP CHAIN
  1442.     patch_wedge((UWORD*)newpatch, 3, &cx->trapped_cnt);    // MATCH CNT
  1443.     patch_wedge((UWORD*)newpatch, 4, &cx->called_cnt);    // NORM CNT
  1444.     patch_wedge((UWORD*)newpatch, 5, cx);                // CTXT PTR
  1445.  
  1446.     Enable();
  1447.  
  1448.     // generate hex string of function code start address
  1449.     len = stcl_h(addr_str+1, (long) cx->stdvector);
  1450.  
  1451.     Move(monrp, PANE_X + ((24-len)*CHAR_WIDTH), PANE_Y +10 + monitored*CHAR_HEIGHT);
  1452.     Text(monrp, addr_str, len+1);
  1453.  
  1454.     return TRUE;        // function successfully added to list
  1455. }
  1456. //-------------------------------------------------------------------------
  1457. // Initialize a Context structure.
  1458. // Fill registers with a no-match template and clear counters.
  1459. //-------------------------------------------------------------------------
  1460. void init_context( struct Context *cx) {
  1461.  
  1462. register int i;
  1463.  
  1464.     // D0 and A7 get special values to get fastest possible "no match"
  1465.  
  1466.     cx->regvals[0] = 0xA1B2C3D4;    cx->regvals[15] = 0x00000000;
  1467.     cx->regmasks[0]= 0xFFFFFFFF;    cx->regmasks[15]= 0xFFFFFFFF;
  1468.  
  1469.     for (i=1; i<15; i++) {                    // skipping D0 and A7 itself
  1470.         cx->regvals[i] = 0;                    // clear interface regs
  1471.         cx->regmasks[i] = 0;
  1472.     }
  1473.  
  1474.     cx->freeze = cx->frozen = FALSE;        // don't freeze on match
  1475.     cx->called_cnt = cx->trapped_cnt = 0;    // clear counters
  1476.     cx->last_called_cnt = cx->last_trapped_cnt = -1;    // force first update
  1477. }
  1478. //-------------------------------------------------------------------------
  1479. // For all patched system functions, see if their call frequency counters
  1480. // have changed since last time and if so re-print them.
  1481. //-------------------------------------------------------------------------
  1482.  
  1483. void refresh_counters(void) {
  1484.  
  1485. char counter_str[]="$0000FFFF   ";        // output buf for bin2hex conversion
  1486. register struct Context *cx;
  1487. struct SysCall **syscall;
  1488. UBYTE oldmask;
  1489. int i;
  1490. register int len;
  1491.  
  1492.     if (!monwindow) return;                // update monitor window if it exists
  1493.  
  1494.     oldmask = monrp->Mask; monrp->Mask = 1;            // write counters in plane 1 only
  1495.  
  1496.     SetDrMd(monrp, JAM2); SetAPen(monrp, 1);        // overwrite mode
  1497.  
  1498.     syscall = patched_calls;            // point to array of SysCall ptrs
  1499.     for(i=1; i <= monitored; i++) {        // for all monitored funcs DO...
  1500.         cx = (*syscall)->ctxt;
  1501.  
  1502.         if (cx->called_cnt != cx->last_called_cnt) {        // if counter changed
  1503.             cx->last_called_cnt = cx->called_cnt;            // old = new
  1504.             len = stcl_h(counter_str+1, cx->called_cnt);    // gen hex
  1505.             len = len > 6 ? 6 : len;
  1506.  
  1507.             Move(monrp, PANE_X + (6-len)*CHAR_WIDTH, PANE_Y+10 + i*CHAR_HEIGHT);
  1508.             Text(monrp, counter_str, len+1);                // print counter
  1509.         }
  1510.  
  1511.         if (cx->trapped_cnt != cx->last_trapped_cnt) {
  1512.             cx->last_trapped_cnt = cx->trapped_cnt;
  1513.             len = stcl_h(counter_str+1, cx->trapped_cnt);
  1514.             len = len > 6 ? 6 : len;
  1515.  
  1516.             Move(monrp, PANE_X + ((8+6)-len)*CHAR_WIDTH, PANE_Y+10 + i*CHAR_HEIGHT);
  1517.             Text(monrp, counter_str, len+1);                // print counter
  1518.         }
  1519.  
  1520.         Move(monrp, PANE_X + (26*CHAR_WIDTH), PANE_Y+10 +i*CHAR_HEIGHT);
  1521.         if (cx->freeze) {
  1522.             if (cx->frozen) {
  1523.                 Text(monrp, "*", 1);
  1524.             } else {
  1525.                 Text(monrp, "!", 1);
  1526.             }
  1527.         } else {
  1528.             Text(monrp, " ", 1);
  1529.         }
  1530.  
  1531.         syscall++;                        // goto next SysCall structure
  1532.     }
  1533.     monrp->Mask = oldmask;                // restore normal bitplane writing mask
  1534. }
  1535. //-------------------------------------------------------------------------
  1536. // User has switched call tracking mode (global <-> Task only)
  1537. // so reset all call counters to start off with clean statistics
  1538. //-------------------------------------------------------------------------
  1539.  
  1540. void reset_counters(void) {
  1541.  
  1542. struct library *lib;
  1543. register struct SysCall *syscall;
  1544. UBYTE oldmask;
  1545.  
  1546.     if (monitored) {                            // clear old counter strings
  1547.         
  1548.         if (!monwindow) printf("BUG in reset_counters!\n");
  1549.  
  1550.         oldmask = monrp->Mask; monrp->Mask = 1;    // Affect 1st bitplane only
  1551.         SetAPen(monrp, 0);
  1552.         RectFill(monrp, PANE_X, PANE_Y+12,
  1553.                         PANE_X+ 15*CHAR_WIDTH -1, PANE_Y+12+ monitored * CHAR_HEIGHT);
  1554.         monrp->Mask = oldmask;                    // restore normal bitplane mask
  1555.     }
  1556.  
  1557.     for (libnum=0; libnum<numlibs; libnum++) {
  1558.         if (libs[libnum].openhandle) {            // only if library valid
  1559.             lib = &libs[libnum];
  1560.             syscall = (struct SysCall*) lib->funcslist.lh_Head;
  1561.             while (syscall->func_node.ln_Succ) {
  1562.                 if (syscall->ctxt) {    // only patched functions have counters...
  1563.                     init_context(syscall->ctxt);
  1564.                 }
  1565.                 syscall = (struct SysCall*) syscall->func_node.ln_Succ;
  1566.  
  1567.             }    // while functions in library
  1568.         }        // if valid library
  1569.     }            // for all slots in libs array
  1570. }
  1571. //-------------------------------------------------------------------------
  1572. // Highlight a rectangle at BOX coordinates x,y that's width wide.
  1573. //-------------------------------------------------------------------------
  1574. void fill_box( int x, int y, int yoffs, int width, struct RastPort *rp, int pen) {
  1575.  
  1576. int ulx,uly;
  1577. UBYTE oldmask;
  1578.  
  1579.     ulx = PANE_X + x * MAX_LABLEN*CHAR_WIDTH;
  1580.     uly = PANE_Y + yoffs+ y * CHAR_HEIGHT;
  1581.  
  1582.     SetDrMd(rp, JAM1); SetAPen(rp, pen);
  1583.     oldmask = rp->Mask; rp->Mask = 2;        // Affect 2nd bitplane only
  1584.  
  1585.     RectFill(rp, ulx, uly, ulx+width, uly+CHAR_HEIGHT-1);
  1586.  
  1587.     rp->Mask = oldmask;                        // restore normal bitplane mask
  1588. } 
  1589. //-------------------------------------------------------------------------
  1590. // Analyze a cached .fd file and extract system call information.
  1591. // Open the Library/Device/Resource of this file to get a firm grip on object.
  1592. //-------------------------------------------------------------------------
  1593.  
  1594. BOOL process_fd_file    (struct FileCache *fc) {
  1595.  
  1596. struct SysCall *funky;                // a ptr to a new System Call "node"
  1597. struct Node *object=NULL;
  1598. char *endquote,*endfunc;
  1599. char *objtype,*newptr;
  1600. register char *ptr;                    // .fd file text scanning ptr
  1601. BOOL skip_private = FALSE;            // skip functions which are system private
  1602. int scan_state = NEED_NAME;            // starting scanning state
  1603. int bias = -6;                        // default starting LVO
  1604.  
  1605.     libs[libnum].numfuncs = 0;        // init # of functions for this library
  1606.     NewList (&libs[libnum].funcslist);
  1607.  
  1608.     ptr = fc->filebuf;                // starting from beginning of cached .fd file
  1609.  
  1610.     while (*ptr) {                    // while not EOF
  1611.         switch (scan_state) {
  1612.  
  1613.             //-----------------------------------------------------------------
  1614.             case NEED_NAME:
  1615.                 if (*ptr++ != '*') return FALSE;
  1616.                 if (*ptr++ != ' ') return FALSE;
  1617.                 if (*ptr++ != '"') return FALSE;
  1618.                 endquote = strchr(ptr, '"');    // find end of quoted str
  1619.                 if (!endquote) return FALSE;
  1620.  
  1621.                 *endquote++ = '\0';                // turn quoted string into C-string
  1622.                 libs[libnum].libname = ptr;
  1623.                 strlwr(ptr);                    // convert name to lower case
  1624.                 objtype = strchr(ptr,'.');        // find what type of "library"
  1625.  
  1626.                 if (FORCEOPEN) {
  1627.                     printf("Forced open option not implemented yet.\n");
  1628. //                    switch (*(objtype+1)) {
  1629. //                        case 'l':    object = OpenLibrary(ptr); break;
  1630. //    **!!                case 'd':    object = OpenDevice(ptr); break;
  1631. //                        case 'r':    object = OpenResource(ptr); break;
  1632. //                    }
  1633. //                } else {
  1634.  
  1635.                 } {
  1636.                     Forbid();
  1637.                         switch (*(objtype+1)) {
  1638.                             case 'l': // LIBRARY
  1639.                                 object = FindName(&SysBase->LibList, ptr); break;
  1640.                             case 'd': // DEVICE
  1641.                                 object = FindName(&SysBase->DeviceList, ptr); break;
  1642.                             case 'r': // RESOURCE
  1643.                                 object = FindName(&SysBase->ResourceList, ptr); break;
  1644.                         }
  1645.  
  1646.             // Make referenced object unswappable by bumping its Use counter !
  1647.  
  1648.  
  1649.                         if (object)    ((struct Library*)object)->lib_OpenCnt++;
  1650.                     Permit();
  1651.                 }
  1652.  
  1653.                 if (!object) {
  1654.                     if (VERBOSE) printf("Object '%s' not available in memory.\n", ptr);
  1655.                     return FALSE;
  1656.                 }
  1657.                 else libs[libnum].openhandle = (struct Library *) object;
  1658.  
  1659.                 ptr = endquote;                    // goto next line;
  1660.                 scan_state = NEUTRAL;
  1661.                 break;
  1662.  
  1663.             //-----------------------------------------------------------------
  1664.             case NEUTRAL:
  1665.  
  1666.                 if (*(ptr-1) != LF) {            // goto new line if not on bound
  1667.                     ptr = 1+ strchr(ptr, LF);
  1668.                 };
  1669.  
  1670.                 switch (*ptr) {                    // determine which line type
  1671.                     case '#':                    // this is and switch state
  1672.                         scan_state = GET_COMMAND;    // accordingly
  1673.                         break;
  1674.  
  1675.                     case '*':
  1676.                         ptr++;
  1677.                         scan_state = NEUTRAL; break;
  1678.  
  1679.                     default:
  1680.                         scan_state = GET_FUNC; break;
  1681.                 }
  1682.                 break;
  1683.  
  1684.             //-----------------------------------------------------------------
  1685.             case GET_FUNC:
  1686.  
  1687.  
  1688.                 if (skip_private) {            // don't collect system private
  1689.                     ptr++;                    // calls
  1690.                     bias += 6;                // keep track of LVO though...
  1691.                     scan_state = NEUTRAL;
  1692.                     break;
  1693.                 }
  1694.  
  1695.                 endfunc = strchr(ptr, '(');    // find '('
  1696.                 *endfunc = '\0';            // turn func name into C-string
  1697.  
  1698.                 funky = node_pool++;        // allocate a new function node
  1699.  
  1700.                 funky->funcname    = ptr;        // fill in name related info
  1701.                 funky->namelen    = endfunc - ptr;
  1702.                 funky->func_LVO    = -bias;    // fill in its _LVO value
  1703.                 funky->ctxt        = NULL;        // not patched yet...
  1704.                 funky->parent_lib= libs[libnum].openhandle;    // link func to lib
  1705.  
  1706.                 AddTail(&libs[libnum].funcslist, (struct Node *)funky);
  1707.  
  1708.                 libs[libnum].numfuncs++;    // track how many functions on list
  1709.                 total_funcs++;                // and stored in total
  1710.  
  1711.                 if (VERBOSE) printf("FUNCTION: %s,\tLVO=-%d\n", ptr, bias);
  1712.  
  1713.                 ptr = 1 + endfunc;            // point past \0 !
  1714.                 bias += 6;                    // keep track of LVO
  1715.  
  1716.                 scan_state = NEUTRAL;
  1717.                 break;
  1718.  
  1719.             //-----------------------------------------------------------------
  1720.             case GET_COMMAND:
  1721.                 ptr++;
  1722.                 if (*ptr++ != '#') return FALSE;
  1723.  
  1724.                 switch (*ptr++) {
  1725.                     case 'b':
  1726.                         if (*ptr == 'i') {            // ##bias
  1727.                             ptr += 3;
  1728.                             bias = strtol(ptr, &newptr, 10);    // get new bias
  1729.                         } else if (*ptr == 'a')    {    // ##base
  1730.                             // name of library base command is skipped
  1731.                         }
  1732.                         break;
  1733.  
  1734.                     case 'e':                        // ##end
  1735.                         ptr = "";    break;            // end the scanning
  1736.  
  1737.                     case 'p':
  1738.                         if (*ptr == 'u') {            // ##public
  1739.                             ptr += 5;
  1740.                             skip_private = FALSE;
  1741.                         } else if (*ptr == 'r')    {    // ##private
  1742.                             ptr += 6;
  1743.                             skip_private = TRUE;
  1744.                         }
  1745.                         break;
  1746.                 }
  1747.                 scan_state = NEUTRAL;
  1748.                 break;
  1749.  
  1750.             //-----------------------------------------------------------------
  1751.         }    // switch (scan_state)
  1752.     }        // while (*ptr)
  1753.  
  1754.     return TRUE;            // Parsed entire .fd file without problems
  1755. }
  1756. //-------------------------------------------------------------------------
  1757. // Open main HeartBeat window (but finish off its menustrip first).
  1758. //-------------------------------------------------------------------------
  1759.  
  1760. BOOL popup_funcwindow (void) {
  1761.  
  1762.     nw.LeftEdge = (screen->Width - nw.Width) /2;    // center window on screen
  1763.  
  1764.     if (!(window = OpenWindow(&nw)))        // Open function selection window
  1765.         return FALSE;                        // WITHOUT IDCMP flags
  1766.  
  1767.     window->UserPort = IDCMPport;            // use global Intuition event MsgPort
  1768.  
  1769.     rp = window->RPort;                        // grab this window's RastPort ptr
  1770.  
  1771.     append_lib_menus();                        // Construct NewMenu array
  1772.  
  1773.     menustrip = CreateMenus(mymenus, TAG_DONE);    // Create MenuStrip
  1774.     if (!menustrip) return FALSE;            // if failed to alloc mem for it...
  1775.  
  1776.     LayoutMenus(menustrip, vi, TAG_DONE);    // Position Menus & Items
  1777.  
  1778.     SetMenuStrip(window, menustrip);        // Attach menu to window
  1779.     OffMenu(window, FULLMENUNUM(OPTIONS_MENU,NOITEM,NOSUB));    // disable menu
  1780.     menus_exist = TRUE;
  1781.  
  1782.     ModifyIDCMP(window, IDCMP_SELECTION);    // tell Intuition to start sending
  1783.  
  1784.     return TRUE;
  1785. }
  1786. //-------------------------------------------------------------------------
  1787. // Part of the MenuStrip is dynamically generated at init time from the
  1788. // list of .fd files we found in the FD: directory.
  1789. // Here we finish off the rest of the array of NewMenu structs.
  1790. //
  1791. // Since we can have a very long list of libraries we have two menus which
  1792. // cope with the two alphabetical groups starting A-I and J-Z.
  1793. //-------------------------------------------------------------------------
  1794.  
  1795. void append_lib_menus(void){
  1796.  
  1797. int i;
  1798. struct NewMenu *newmenu;
  1799.  
  1800.     lowlibs = 0;                    // count how many are in first menu
  1801.     newmenu = mymenus + NEWMENU_APPEND;    // point at the first empty slot
  1802.  
  1803.     for (i=0; i<numlibs; i++) {        // if lib name starts with A..I
  1804.         if (toupper(libs[i].libname[0]) <= 'I') {    // and .fd file was
  1805.             if (libs[i].numfuncs) {                    // parsed succesfully
  1806.                 newmenu->nm_Type    = NM_ITEM;
  1807.                 newmenu->nm_Label    = libs[i].libname;
  1808.                 newmenu->nm_CommKey    = NULL;
  1809.                 newmenu->nm_Flags    = 0;
  1810.                 newmenu->nm_MutualExclude = 0L;
  1811.                 newmenu++;
  1812.                 lowlibs++;
  1813.             }
  1814.         }
  1815.     }
  1816.  
  1817. // Now construct the Menu for Libraries J-Z.
  1818.  
  1819.     newmenu->nm_Type    = NM_TITLE;    // Insert a MENU TITLE for 2nd Libraries
  1820.     newmenu->nm_Label    = "Libraries J-Z";
  1821.     newmenu->nm_CommKey    = NULL;
  1822.     newmenu->nm_Flags    = 0;
  1823.     newmenu->nm_MutualExclude = 0L;
  1824.  
  1825.     newmenu++;                        // and group all other libraries under 2nd
  1826.  
  1827.     for (i=0; i<numlibs; i++) {
  1828.         if (toupper(libs[i].libname[0]) >= 'J') {
  1829.             if (libs[i].numfuncs) {
  1830.                 newmenu->nm_Type    = NM_ITEM;
  1831.                 newmenu->nm_Label    = libs[i].libname;
  1832.                 newmenu->nm_CommKey    = NULL;
  1833.                 newmenu->nm_Flags    = 0;
  1834.                 newmenu->nm_MutualExclude = 0L;
  1835.                 newmenu++;
  1836.             }
  1837.         }
  1838.     }
  1839.  
  1840. // Add final end marker.
  1841.  
  1842.     newmenu->nm_Type    = NM_END;    // Terminate NewMenu array with the required
  1843.     newmenu->nm_Label    = NULL;        // end marker
  1844.     newmenu->nm_CommKey    = NULL;
  1845.     newmenu->nm_Flags    = 0;
  1846.     newmenu->nm_MutualExclude = 0L;
  1847. }
  1848.  
  1849. //-------------------------------------------------------------------------
  1850. struct taskinfo {            // struct is private to ask_task(), get_task_sel()
  1851.     struct Node ti_node;
  1852.     struct Task *ti_Task;    // ptr to Task for when we get selection
  1853.     char   taskname[8+2+MAX_TASKLAB];    // 8 chars for hex Task ptr and N for name itself
  1854. };
  1855.  
  1856. //-------------------------------------------------------------------------
  1857. // User wants to change which Task he's snooping on.
  1858. //
  1859. // Traverse system Task lists and construct a local (static) list of Tasks
  1860. // with their names and hex TCB addresses for a LISTVIEW gadget to display.
  1861. // Open a window with this LISTVIEW and two more "USE", "CANCEL" gadgets.
  1862. // Don't wait for an answer here. Return immediately. Main loop will handle
  1863. // selection and the closing of this window.
  1864. //-------------------------------------------------------------------------
  1865.  
  1866. BOOL ask_task (char *wintitle) {
  1867.  
  1868. static struct TagItem ListViewTags[] =    {
  1869.     GTLV_Labels, NULL,                // filled in with &taskList
  1870.     GTLV_Top, 0,
  1871.     LAYOUTA_SPACING, 1,
  1872.     GTLV_ShowSelected, NULL,        // add read-only label showing selected item
  1873.     GTLV_Selected, 0,
  1874.     GTLV_ScrollWidth, 16,            // width of scroll bar
  1875.     TAG_DONE
  1876. };
  1877.  
  1878. struct NewGadget ng = {                // Not static coz we want stuff re-initialized
  1879.         PANE_X+3,PANE_Y+2,
  1880.         32*CHAR_WIDTH, 14*CHAR_HEIGHT,
  1881.         "List of Tasks", NULL, NULL,
  1882.         PLACETEXT_BELOW,
  1883.         NULL, NULL
  1884. };
  1885.  
  1886. struct Gadget        *lastgad;
  1887. struct NewWindow    *nW;
  1888.  
  1889.     NewList(&taskList);                    // initialize list header
  1890.  
  1891.     Forbid();                            // freeze view of system lists
  1892.  
  1893.     // accumulate Tasks that are WAITing
  1894.     collect_taskinfo(SysBase->TaskWait.lh_Head);
  1895.  
  1896.     // Also give user access to Tasks which are currently ready to run.
  1897.     // This is very useful since Tasks which crash usually use up their
  1898.     // entire time quantum and therefore are constantly READY.
  1899.  
  1900.     collect_taskinfo(SysBase->TaskReady.lh_Head);
  1901.  
  1902.     Permit();
  1903.  
  1904.     // Now that we've constructed a list of names suitable for a LISTVIEW,
  1905.     // construct gadget and window.
  1906.  
  1907.     ng.ng_VisualInfo = vi;
  1908.     ng.ng_TextAttr     = TAttr;
  1909.     ng.ng_GadgetID     = 0;
  1910.  
  1911.     taskReqGads = NULL; lastgad = CreateContext( &taskReqGads );
  1912.  
  1913.     ListViewTags[0].ti_Data = (ULONG) &taskList;    // pass tasknames to Gadget
  1914.     ng.ng_GadgetID    = 0;
  1915.     lastgad = CreateGadgetA(LISTVIEW_KIND, lastgad, &ng, (struct TagItem *) ListViewTags);
  1916.  
  1917.     // Add "Use" and "Cancel" Gadgets
  1918.  
  1919.     ng.ng_GadgetID++; ng.ng_GadgetText = "Use";
  1920.     ng.ng_Flags        = PLACETEXT_IN;
  1921.     ng.ng_Width        = 7*CHAR_WIDTH;
  1922.     ng.ng_LeftEdge  = 60;
  1923.     ng.ng_TopEdge  += ng.ng_Height + 8;
  1924.     ng.ng_Height    = CHAR_HEIGHT+3;
  1925.     lastgad = CreateGadget(BUTTON_KIND, lastgad, &ng, TAG_DONE);
  1926.  
  1927.     ng.ng_GadgetID++; ng.ng_GadgetText = "Cancel";
  1928.     ng.ng_LeftEdge    = 150;
  1929.               CreateGadget(BUTTON_KIND, lastgad, &ng, TAG_DONE);
  1930.  
  1931.     nW = &nw;
  1932.     nW->Title        = wintitle;
  1933.     nW->TopEdge        = 40;
  1934.     nW->LeftEdge    = 100;
  1935.     nW->Width        = 274;
  1936.     nW->Height        = 150;
  1937.     nW->Flags        = WINDOWCLOSE| ACTIVATE| WINDOWDEPTH| WINDOWDRAG;
  1938.     nW->IDCMPFlags    = 0;
  1939.  
  1940.     taskwindow = OpenWindow(nW);                // open task requester window
  1941.  
  1942.     AddGList(taskwindow, taskReqGads, -1, -1, NULL); // append at end, all gadgets
  1943.     RefreshGList(taskReqGads, taskwindow, NULL, -1); // display new ones
  1944.     GT_RefreshWindow(taskwindow, NULL);
  1945.  
  1946.     taskwindow->UserPort = IDCMPport;            // use global event port
  1947.     ModifyIDCMP(taskwindow, IDCMP_SELECTION);    // enable transmissions
  1948.  
  1949.     app_state = TASKWINDOW; task_num = 0;    // first item is selected by default
  1950.  
  1951.     return TRUE;
  1952. }
  1953. //-------------------------------------------------------------------------
  1954. // Traverse Task/Process list and collect name, TCB addr and CLI num info
  1955. //-------------------------------------------------------------------------
  1956. void collect_taskinfo (struct Node *task) {
  1957.  
  1958. struct taskinfo    *node;
  1959. int len,cli;
  1960.  
  1961.     while (task->ln_Succ) {
  1962.         node = (struct taskinfo*) AllocMem(sizeof (struct taskinfo),MEMF_PUBLIC);
  1963.         node->ti_Task = (struct Task*) task;
  1964.         node->ti_node.ln_Name = node->taskname;
  1965.  
  1966.             // make sure both fields aren't separated by a \0
  1967.         strcpy(node->taskname, "          ");            // pad with spaces
  1968.         len = stcl_h(node->taskname, (int) task);        // print task address
  1969.  
  1970.         stccpy(node->taskname+10, task->ln_Name, MAX_TASKLAB);    // and taskname
  1971.         *(node->taskname + len) = ' ';                    // glue both strings together
  1972.  
  1973.         if (task->ln_Type == NT_PROCESS) {    // If a PROCESS also print CLI num
  1974.             cli = ((struct Process*)task)->pr_TaskNum;
  1975.             if (cli) {                        // only non-zero CLI nums valid
  1976.                 *(node->taskname +8 ) = '0' +cli;
  1977.             }
  1978.         }
  1979.  
  1980.         AddTail(&taskList, (struct Node *) node);
  1981.         task = task->ln_Succ;
  1982.     }
  1983. }
  1984. //-------------------------------------------------------------------------
  1985. // User clicked on CLOSEWINDOW, USE or CANCEL gadget and we have to release
  1986. // our Task information list, gadget memory and window.
  1987. //-------------------------------------------------------------------------
  1988. void kill_taskReq_window(void) {
  1989.  
  1990. struct taskinfo *node,*nodex;
  1991.  
  1992.     node = (struct taskinfo*) taskList.lh_Head;
  1993.     while (nodex = (struct taskinfo*) node->ti_node.ln_Succ) {
  1994.         FreeMem((APTR) node, sizeof (struct taskinfo));
  1995.         node = nodex;
  1996.     }
  1997.  
  1998.     CloseWindowSafely(taskwindow); taskwindow = NULL;
  1999.  
  2000.     FreeGadgets(taskReqGads);                    // free CreateGadget RAM
  2001. }
  2002. //-------------------------------------------------------------------------
  2003. // Find Task # N in our Task information list and point SNOOP_TASK to it.
  2004. //-------------------------------------------------------------------------
  2005. void watch_task(int index) {
  2006.  
  2007. struct taskinfo *node;
  2008.  
  2009.     node = (struct taskinfo*) taskList.lh_Head;
  2010.  
  2011.     while(index--) {
  2012.             // just follow list and find node number N
  2013.         node = (struct taskinfo*) node->ti_node.ln_Succ;
  2014.     }
  2015.  
  2016.     SNOOP_TASK = node->ti_Task;            // set address of Task to be snooped
  2017. }
  2018. //-------------------------------------------------------------------------
  2019. // Pop up the register match window sprinkled with loads of GadTools Gadgets.
  2020. // HeartBeat allows us to monitor functions which get specific arguments.
  2021. // This is done by specifying the contents of the data and address registers
  2022. // when the system function gets called.
  2023. // Masks are used to ignore whole registers or parts of registers.
  2024. // When a function is being traced in this "arguments" mode and the arguments
  2025. // match the template then HeartBeat will either simply increment a counter
  2026. // or FREEZE the calling Task.
  2027. //-------------------------------------------------------------------------
  2028.  
  2029. BOOL ask_register_info (char *wintitle, struct Context *ctxt) {
  2030.  
  2031. int regs;
  2032. char *hexstr="$xxxxyyyy";
  2033. static char *actions[] = {    "Count on match",
  2034.                             "Freeze on match", NULL };
  2035.  
  2036. static char *regnames[] = { "D0","D1","D2","D3","D4","D5","D6","D7",
  2037.                             "A0","A1","A2","A3","A4","A5","A6","A7" };
  2038. struct NewGadget ng = {
  2039.     PANE_X, PANE_Y+12,
  2040.     12*CHAR_WIDTH, CHAR_HEIGHT+4,
  2041.     NULL, NULL, NULL,
  2042.     0,
  2043.     NULL, NULL };
  2044.  
  2045. struct Gadget *lastgad;
  2046. struct NewWindow *nW;
  2047.  
  2048.     ctxt->freeze = ctxt->frozen = FALSE;    // sync up with what Gadget shows!
  2049.  
  2050.     ng.ng_VisualInfo = vi;
  2051.     ng.ng_TextAttr     = TAttr;
  2052.     ng.ng_GadgetID     = 0;
  2053.  
  2054.     regsReqGads = NULL; lastgad = CreateContext( ®sReqGads );
  2055.  
  2056.     // Create 16 String Gadgets. Two per 680x0 register for value and mask.
  2057.  
  2058.     for (regs=0; regs < 16; regs++) {
  2059.         sprintf(hexstr, "$%lX", ctxt->regvals[regs]);
  2060.         ng.ng_Flags            = PLACETEXT_RIGHT;
  2061.         ng.ng_GadgetText    = regnames[regs];
  2062.         lastgad = CreateGadget(STRING_KIND, lastgad, &ng, GTST_String, hexstr, TAG_DONE);
  2063.         
  2064.         sprintf(hexstr, "$%lX", ctxt->regmasks[regs]);
  2065.         ng.ng_GadgetID++;
  2066.         ng.ng_GadgetText    = NULL;
  2067.         ng.ng_Flags            = 0;
  2068.         ng.ng_LeftEdge        += 10*CHAR_WIDTH + 48;
  2069.         lastgad = CreateGadget(STRING_KIND, lastgad, &ng, GTST_String, hexstr, TAG_DONE);
  2070.  
  2071.         ng.ng_LeftEdge -= 10*CHAR_WIDTH + 48;
  2072.         ng.ng_TopEdge  += CHAR_HEIGHT+4 +1;
  2073.         ng.ng_GadgetID++;
  2074.     }
  2075.  
  2076.     // Add Trapping mode (Cycleing) Gadget
  2077.  
  2078.     ng.ng_Flags        = PLACETEXT_IN | NG_HIGHLABEL;
  2079.     ng.ng_Width        = 20*CHAR_WIDTH;
  2080.     ng.ng_LeftEdge  = PANE_X;
  2081.     ng.ng_TopEdge  += 10;
  2082.     lastgad = CreateGadget(CYCLE_KIND, lastgad, &ng, GTCY_Labels, actions, TAG_DONE);
  2083.  
  2084.     // Add "Use" and "Cancel" Gadgets
  2085.  
  2086.     ng.ng_Flags        = PLACETEXT_IN;
  2087.     ng.ng_GadgetID++; ng.ng_GadgetText = "Use";
  2088.     ng.ng_Width        = 7*CHAR_WIDTH;
  2089.     ng.ng_LeftEdge  = 44;
  2090.     ng.ng_TopEdge  += 20;
  2091.     lastgad = CreateGadget(BUTTON_KIND, lastgad, &ng, TAG_DONE);
  2092.  
  2093.     ng.ng_GadgetID++; ng.ng_GadgetText = "Cancel";
  2094.     ng.ng_LeftEdge    += 90;
  2095.     lastgad = CreateGadget(BUTTON_KIND, lastgad, &ng, TAG_DONE);
  2096.  
  2097.     // Open Window for Gadgets to live in
  2098.  
  2099.     nW = &nw;
  2100.     nW->Title = wintitle;
  2101.     nW->TopEdge = 40; nW->LeftEdge = 100;
  2102.     nW->Width = 236; nW->Height = 280;
  2103.     nW->Flags = WINDOWCLOSE| ACTIVATE| WINDOWDEPTH| WINDOWDRAG;
  2104.     nW->IDCMPFlags = 0;
  2105.  
  2106.     regswindow = OpenWindow(nW);        //**!! error
  2107.     regsrp = regswindow->RPort;
  2108.  
  2109.     AddGList(regswindow, regsReqGads, -1, -1, NULL);
  2110.     RefreshGList(regsReqGads, regswindow, NULL, -1);
  2111.     GT_RefreshWindow(regswindow, NULL);
  2112.  
  2113.     Move(regsrp, PANE_X+28, PANE_Y+7);
  2114.     SetAPen(regsrp,1);
  2115.     Text(regsrp,"Values          Masks",20);
  2116.  
  2117.     regswindow->UserPort = IDCMPport;                // use global event port
  2118.     ModifyIDCMP(regswindow, IDCMP_SELECTION);        // enable transmissions
  2119.  
  2120.     app_state = REGSWINDOW;
  2121.  
  2122.     // Add this stage the window sits there with all its Gadgets waiting for
  2123.     // input; but this function returns now, so it's the main event loop that
  2124.     // picks up the user selections and then eventually kills the window
  2125.     // when "Use", "Cancel" or the CLOSEWINDOW Gadget gets selected.
  2126.  
  2127.     return TRUE;
  2128. }
  2129. //-------------------------------------------------------------------------
  2130. // User clicked on CLOSEWINDOW, USE or CANCEL gadget and we have to release
  2131. // our Window and gadget memory.
  2132. //-------------------------------------------------------------------------
  2133. void kill_regsReq_window(void) {
  2134.  
  2135.     CloseWindowSafely(regswindow); regswindow = NULL;
  2136.  
  2137.     FreeGadgets(regsReqGads);                    // free CreateGadget RAM
  2138. }
  2139. //-------------------------------------------------------------------------
  2140. // Turn a cached text file into a collection of C-strings (a heap of strings)
  2141. //-------------------------------------------------------------------------
  2142. void text_to_heap( struct FileCache *fc) {
  2143. register int i;
  2144. register char * ptr;
  2145.  
  2146.     ptr = fc->filebuf;
  2147.  
  2148.     for (i=fc->bufsize; i; i--) {
  2149.         if (*ptr == LF)                // replace all LF chars by string terminators
  2150.             *ptr = '\0';
  2151.         ptr++;
  2152.     }
  2153. }
  2154.  
  2155. //-------------------------------------------------------------------------
  2156. // Turn a LF-terminated string into a proper C-string.
  2157. //-------------------------------------------------------------------------
  2158. void strip_lf (char *str) {
  2159.  
  2160.     while (*str++ != LF)        // go find terminating LF
  2161.         ;
  2162.  
  2163.     *(str-1) = 0;                // and replace by a \0
  2164. }
  2165. //-------------------------------------------------------------------------
  2166. // Close Window safely (taking care of possible queued messages)
  2167. //-------------------------------------------------------------------------
  2168. void CloseWindowSafely( struct Window *win ) {
  2169.     
  2170.     if (win->UserPort) {
  2171.         Forbid();    // we forbid here to keep out of race conditions with Intuition
  2172.  
  2173.             // return any messages for this window that have not yet been processed
  2174.             StripIntuiMessages( win->UserPort, win );
  2175.  
  2176.             win->UserPort = NULL;        // clear UserPort so Intuition will not free it
  2177.             ModifyIDCMP( win, 0L );        // tell inuition to stop sending more messages
  2178.  
  2179.         Permit();                        // turn tasking back on
  2180.     }
  2181.  
  2182.     CloseWindow( win );                // and really close the window
  2183. }
  2184. //-------------------------------------------------------------------------
  2185. // remove and reply to all IntuiMessages on a port that have been sent to a
  2186. // particular window (note that we don't rely on the ln_Succ pointer of a
  2187. // message after we have replied it)
  2188. //-------------------------------------------------------------------------
  2189. void StripIntuiMessages(struct MsgPort *mp, struct Window *win ) {
  2190.  
  2191. register struct IntuiMessage *msg;
  2192. register struct Node *succ;
  2193.  
  2194.     msg = (struct IntuiMessage *) mp->mp_MsgList.lh_Head;    // 1st message
  2195.  
  2196.     while( succ = msg->ExecMessage.mn_Node.ln_Succ ) {
  2197.  
  2198.         if( msg->IDCMPWindow ==  win ) {                    // message addressed
  2199.                                                             // to us ?
  2200.          // Intuition is about to free this message.
  2201.          // Make sure that we have politely sent it back.
  2202.  
  2203.             Remove((struct Node*)msg);
  2204.             ReplyMsg((struct Message*)msg);
  2205.         }
  2206.         
  2207.         msg = (struct IntuiMessage *) succ;        // next IntuiMessage on list
  2208.     }
  2209. }
  2210. //-------------------------------------------------------------------------
  2211. // Open all libraries, initialize arrays, get private memory pool,
  2212. // open two IPC Message Ports (one for timeout messages, one for all Intuition
  2213. // messages), open timer.device, set global function tracking mode.
  2214. //-------------------------------------------------------------------------
  2215.  
  2216. BOOL init_program(void) {
  2217. int i;
  2218.  
  2219.     if (!(AslBase        = (struct AslBase *)      OpenLibrary( "asl.library",0L)))
  2220.         return FALSE;
  2221.     if (!(GadToolsBase  = (struct GadToolsBase *) OpenLibrary( "gadtools.library",0L)))
  2222.         return FALSE;
  2223.     if (!(IntuitionBase = (struct IntuitionBase*) OpenLibrary("intuition.library",0L)))
  2224.         return FALSE;
  2225.     if (!(GfxBase        = (struct GfxBase *)      OpenLibrary( "graphics.library",0L)))
  2226.         return FALSE;
  2227.  
  2228.     screen    = IntuitionBase->ActiveScreen;    // note host Screen
  2229.     TAttr    = screen->Font;                    // note Screen default Font
  2230.     vi        = GetVisualInfo(screen, TAG_DONE);
  2231.  
  2232.     // Mark all file caches as empty
  2233.     FdDirCache.bufsize = 0;
  2234.  
  2235.     for (i=0; i< MAX_LIBS; i++) {
  2236.         fd_caches[i].bufsize = 0;            // all caches are empty
  2237.         libs[i].openhandle     = NULL;        // all libs are unopened
  2238.     }
  2239.  
  2240.     // Mark all patched system call links as invalid
  2241.     monitored = 0;                            // no calls monitored yet..
  2242.     for (i=0; i< MAX_PATCHED; i++) {        // no patched calls yet...
  2243.         patched_calls[i] = NULL;
  2244.     }
  2245.  
  2246.     // Get a large memory pool to hold System Call information
  2247.     pool_base = node_pool = (struct SysCall *) AllocMem(POOL_SIZE, MEMF_PUBLIC|MEMF_CLEAR);
  2248.  
  2249.     if (!pool_base) {
  2250.         printf("Unable to allocate memory pool.\n");
  2251.         return FALSE;
  2252.     }
  2253.  
  2254.     // Create our event message ports
  2255.     if (!(timerport = CreateMsgPort())) return FALSE;
  2256.     if (!(IDCMPport = CreateMsgPort())) return FALSE;
  2257.  
  2258.     if (OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest*) &timereq, 0)) {
  2259.         printf("Failed to open timer.device\n");
  2260.         return FALSE;
  2261.     }
  2262.  
  2263.     timereq.tr_node.io_Message.mn_ReplyPort = timerport;
  2264.  
  2265.     SNOOP_TASK = NULL;                        // global tracking mode on
  2266.  
  2267.     monwindow = taskwindow = regswindow = NULL;    // no special windows up
  2268.  
  2269.     return TRUE;
  2270. }
  2271. //-------------------------------------------------------------------------
  2272. // Unpatch any patched functions.
  2273. // Unlock resources (Libraries, Devices, Resources)
  2274. // Deallocate all file buffers still in use.
  2275. //-------------------------------------------------------------------------
  2276.  
  2277. void cleanup(void) {
  2278. int i,size;
  2279.  
  2280.     unpatch_functions();
  2281.  
  2282.         // Release all the .FD file caches
  2283.     for (i=0; i< MAX_LIBS; i++) {
  2284.         size = fd_caches[i].bufsize;
  2285.         if (size) {
  2286.             FreeMem(fd_caches[i].filebuf, size);
  2287.         }
  2288.     }
  2289.  
  2290.     size = FdDirCache.bufsize;
  2291.     if (size)
  2292.          FreeMem(FdDirCache.filebuf, size);
  2293.  
  2294.         // Release all the libraries/devices/resources which we locked
  2295.     for (libnum=0; libnum<numlibs; libnum++) {
  2296.         if (libs[libnum].openhandle)
  2297.             libs[libnum].openhandle->lib_OpenCnt--;
  2298.     }
  2299.  
  2300.         // Free all SysCall structures (pool)
  2301.     if (pool_base)
  2302.         FreeMem((char*)pool_base, POOL_SIZE);
  2303.  
  2304.     if (IntuitionBase) {
  2305.         if (window) {
  2306.             window->UserPort = NULL;    // Intuition: leave MY port alone!
  2307.             if (menus_exist) {
  2308.                 ClearMenuStrip(window);
  2309.                 FreeMenus(menustrip);
  2310.             }
  2311.             CloseWindowSafely(window);
  2312.         }
  2313.         FreeVisualInfo(vi);
  2314.         CloseLibrary( (struct Library *) IntuitionBase);
  2315.     }
  2316.  
  2317.     if (AslBase) {
  2318.         CloseLibrary( (struct Library *) AslBase);
  2319.     }
  2320.  
  2321.     if (GadToolsBase) {
  2322.         CloseLibrary( (struct Library *) GadToolsBase);
  2323.     }
  2324.  
  2325.     if (GfxBase)      {
  2326.         CloseLibrary( (struct Library *) GfxBase);
  2327.     }
  2328.  
  2329.     if (timerport) DeleteMsgPort((struct MsgPort*)timerport);
  2330.     if (IDCMPport) DeleteMsgPort((struct MsgPort*)IDCMPport);
  2331.  
  2332.     CloseDevice((struct IORequest*) &timereq);
  2333.  
  2334.     exit(0);
  2335. }
  2336. //-------------------------------------------------------------------------
  2337. // For all functions which we've patched to track their use, undo all.
  2338. //-------------------------------------------------------------------------
  2339.  
  2340. void unpatch_functions(void) {
  2341.  
  2342. int i;
  2343. struct SysCall *syscall;
  2344.  
  2345.     if (!monitored) return;            // if nothing to unpatch... don't
  2346.  
  2347.     // Unpatch all functions which HeartBeat patched.
  2348.  
  2349.     for (i=0; i<monitored; i++) {
  2350.  
  2351.         syscall = patched_calls[i];
  2352.         if (VERBOSE) printf("Unpatching Call %s, %x \n",
  2353.                          syscall->funcname, syscall->ctxt->stdvector);
  2354.  
  2355.         SetFunction(syscall->parent_lib, syscall->func_LVO, syscall->ctxt->stdvector );
  2356.         syscall->ctxt = NULL;
  2357.     }
  2358.  
  2359.     ctxt_pool = (void*) node_pool;    // reset Contexts pool ptr
  2360.     monitored = 0;                    // reset # of monitored functions
  2361. }
  2362. //-------------------------------------------------------------------------
  2363.